Check allignment of sub heap allocation in vulkan

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 64 matching lines @@
     }
 
     GrVkHeap* heap = gpu->getHeap(buffer_type_to_heap(type));
 
     if (!heap->alloc(memReqs.size, memReqs.alignment, typeIndex, alloc)) {
         SkDebugf("Failed to alloc buffer\n");
         return false;
     }
 
     // Bind Memory to device
-    VkResult err = GR_VK_CALL(iface, BindBufferMemory(device, buffer, 
+    VkResult err = GR_VK_CALL(iface, BindBufferMemory(device, buffer,
                                                       alloc->fMemory, alloc->fOffset));
     if (err) {
         SkASSERT_RELEASE(heap->free(*alloc));
         return false;
     }
 
     return true;
 }
 
 void GrVkMemory::FreeBufferMemory(const GrVkGpu* gpu, GrVkBuffer::Type type,
@@ skipping 326 matching lines @@
     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, 
+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) {
+        if (fSubHeaps[i]->memoryTypeIndex() == memoryTypeIndex &&
+            fSubHeaps[i]->alignment() == alignment) {
             VkDeviceSize heapSize = fSubHeaps[i]->largestBlockSize();
             if (heapSize >= alignedSize && heapSize < bestFitSize) {
                 bestFitIndex = i;
                 bestFitSize = heapSize;
             }
         }
     }
 
     if (bestFitIndex >= 0) {
         SkASSERT(fSubHeaps[bestFitIndex]->alignment() == alignment);

[egdaniel, 2016/08/10 14:46:04]

This assert fires without the change

         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, 
+bool GrVkHeap::singleAlloc(VkDeviceSize size, VkDeviceSize alignment,
                            uint32_t memoryTypeIndex, GrVkAlloc* alloc) {
     VkDeviceSize alignedSize = align_size(size, alignment);
 
     // first try to find an unallocated 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 && fSubHeaps[i]->unallocated()) {
+        if (fSubHeaps[i]->memoryTypeIndex() == memoryTypeIndex &&
+            fSubHeaps[i]->alignment() == alignment &&
+            fSubHeaps[i]->unallocated()) {
             VkDeviceSize heapSize = fSubHeaps[i]->size();
             if (heapSize >= alignedSize && heapSize < bestFitSize) {
                 bestFitIndex = i;
                 bestFitSize = heapSize;
             }
         }
     }
 
     if (bestFitIndex >= 0) {
         SkASSERT(fSubHeaps[bestFitIndex]->alignment() == alignment);
@@ skipping 29 matching lines @@
             fSubHeaps[i]->free(alloc);
             fUsedSize -= alloc.fSize;
             return true;
         }
     }
 
     return false;
 }