Check for some potential subheap allocation failures.

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 342 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);
 
         return true;
     }
     
     SkDebugf("Can't allocate %d bytes, %d bytes available, largest free block %d\n", alignedSize, fFreeSize, fLargestBlockSize);
 
     return false;
 }
 
 
@@ skipping 60 matching lines @@
 #endif
 }
 
 GrVkHeap::~GrVkHeap() {
 }
 
 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
+            NULL,                                        // pNext
+            size,                                        // allocationSize
+            memoryTypeIndex,                             // memoryTypeIndex
+        };
+
+        VkResult err = GR_VK_CALL(fGpu->vkInterface(), AllocateMemory(fGpu->device(),
+                                                                      &allocInfo,
+                                                                      nullptr,
+                                                                      &alloc->fMemory));
+        if (VK_SUCCESS != err) {
+            return false;
+        }
+        alloc->fOffset = 0;
+        alloc->fSize = 0;    // hint that this is not a subheap allocation
+        
+        return true;
+    }
+
     // first try to find a subheap that fits our allocation request
     int bestFitIndex = -1;
     VkDeviceSize bestFitSize = 0x7FFFFFFF;
     for (auto i = 0; i < fSubHeaps.count(); ++i) {
         if (fSubHeaps[i]->memoryTypeIndex() == memoryTypeIndex) {
             VkDeviceSize heapSize = fSubHeaps[i]->largestBlockSize();
             if (heapSize >= alignedSize && heapSize < bestFitSize) {
                 bestFitIndex = i;
                 bestFitSize = heapSize;
             }
         }
     }
 
     if (bestFitIndex >= 0) {
         SkASSERT(fSubHeaps[bestFitIndex]->alignment() == alignment);
         if (fSubHeaps[bestFitIndex]->alloc(size, alloc)) {
             fUsedSize += alloc->fSize;
             return true;
         }
         return false;
-    } 
+    }
 
     // need to allocate a new subheap
     SkAutoTDelete<GrVkSubHeap>& subHeap = fSubHeaps.push_back();
     subHeap.reset(new GrVkSubHeap(fGpu, memoryTypeIndex, fSubHeapSize, alignment));
+    // try to recover from failed allocation by only allocating what we need
+    if (subHeap->size() == 0) {
+        VkDeviceSize alignedSize = align_size(size, alignment);
+        subHeap.reset(new GrVkSubHeap(fGpu, memoryTypeIndex, alignedSize, alignment));
+        if (subHeap->size() == 0) {
+            return false;
+        }
+    }
     fAllocSize += fSubHeapSize;
     if (subHeap->alloc(size, alloc)) {
         fUsedSize += alloc->fSize;
         return true;
     }
 
     return false;
 }
 
 bool GrVkHeap::singleAlloc(VkDeviceSize size, VkDeviceSize alignment, 
@@ skipping 28 matching lines @@
     fAllocSize += alignedSize;
     if (subHeap->alloc(size, alloc)) {
         fUsedSize += alloc->fSize;
         return true;
     }
 
     return false;
 }
 
 bool GrVkHeap::free(const GrVkAlloc& alloc) {
+    // a size of 0 means we're using the system heap
+    if (0 == alloc.fSize) {
+        const GrVkInterface* iface = fGpu->vkInterface();
+        GR_VK_CALL(iface, FreeMemory(fGpu->device(), alloc.fMemory, nullptr));
+        return true;
+    }
+
     for (auto i = 0; i < fSubHeaps.count(); ++i) {
         if (fSubHeaps[i]->memory() == alloc.fMemory) {
             fSubHeaps[i]->free(alloc);
             fUsedSize -= alloc.fSize;
             return true;
         }
     }
 
     return false;
 }