Revert of Some Vulkan memory fixes and cleanup

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"
 #include "GrVkUtil.h"
 
-#ifdef SK_DEBUG
-// for simple tracking of how much we're using in each heap
-// last counter is for non-subheap allocations
-VkDeviceSize gHeapUsage[VK_MAX_MEMORY_HEAPS+1] = { 0 };
-#endif
-
 static bool get_valid_memory_type_index(const VkPhysicalDeviceMemoryProperties& physDevMemProps,
                                         uint32_t typeBits,
                                         VkMemoryPropertyFlags requestedMemFlags,
-                                        uint32_t* typeIndex,
-                                        uint32_t* heapIndex) {
+                                        uint32_t* typeIndex) {
     for (uint32_t i = 0; i < physDevMemProps.memoryTypeCount; ++i) {
         if (typeBits & (1 << i)) {
             uint32_t supportedFlags = physDevMemProps.memoryTypes[i].propertyFlags &
                                       requestedMemFlags;
             if (supportedFlags == requestedMemFlags) {
                 *typeIndex = i;
-                *heapIndex = physDevMemProps.memoryTypes[i].heapIndex;
                 return true;
             }
         }
     }
     return false;
 }
 
 static GrVkGpu::Heap buffer_type_to_heap(GrVkBuffer::Type type) {
     const GrVkGpu::Heap kBufferToHeap[]{
         GrVkGpu::kVertexBuffer_Heap,
@@ skipping 16 matching lines @@
                                           GrVkBuffer::Type type,
                                           bool dynamic,
                                           GrVkAlloc* alloc) {
     const GrVkInterface* iface = gpu->vkInterface();
     VkDevice device = gpu->device();
 
     VkMemoryRequirements memReqs;
     GR_VK_CALL(iface, GetBufferMemoryRequirements(device, buffer, &memReqs));
 
     uint32_t typeIndex = 0;
-    uint32_t heapIndex = 0;
     const VkPhysicalDeviceMemoryProperties& phDevMemProps = gpu->physicalDeviceMemoryProperties();
     if (dynamic) {
         // try to get cached and ideally non-coherent memory first
         if (!get_valid_memory_type_index(phDevMemProps,
                                          memReqs.memoryTypeBits,
                                          VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
                                          VK_MEMORY_PROPERTY_HOST_CACHED_BIT,
-                                         &typeIndex,
-                                         &heapIndex)) {
+                                         &typeIndex)) {
             // some sort of host-visible memory type should always be available for dynamic buffers
             SkASSERT_RELEASE(get_valid_memory_type_index(phDevMemProps,
                                                          memReqs.memoryTypeBits,
                                                          VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-                                                         &typeIndex,
-                                                         &heapIndex));
+                                                         &typeIndex));
         }
 
         VkMemoryPropertyFlags mpf = phDevMemProps.memoryTypes[typeIndex].propertyFlags;
         alloc->fFlags = mpf & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT ? 0x0
                                                                    : GrVkAlloc::kNoncoherent_Flag;
     } else {
         // device-local memory should always be available for static buffers
         SkASSERT_RELEASE(get_valid_memory_type_index(phDevMemProps,
                                                      memReqs.memoryTypeBits,
                                                      VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
-                                                     &typeIndex,
-                                                     &heapIndex));
+                                                     &typeIndex));
         alloc->fFlags = 0x0;
     }
 
     GrVkHeap* heap = gpu->getHeap(buffer_type_to_heap(type));
 
-    if (!heap->alloc(memReqs.size, memReqs.alignment, typeIndex, heapIndex, alloc)) {
-        // if static, try to allocate from non-host-visible non-device-local memory instead
-        if (dynamic ||
-            !get_valid_memory_type_index(phDevMemProps, memReqs.memoryTypeBits, 
-                                         0, &typeIndex, &heapIndex) ||
-            !heap->alloc(memReqs.size, memReqs.alignment, typeIndex, heapIndex, alloc)) {
-            SkDebugf("Failed to alloc buffer\n");
-            return false;
-        }
+    if (!heap->alloc(memReqs.size, memReqs.alignment, typeIndex, alloc)) {
+        SkDebugf("Failed to alloc buffer\n");
+        return false;
     }
 
     // Bind buffer
     VkResult err = GR_VK_CALL(iface, BindBufferMemory(device, buffer,
                                                       alloc->fMemory, alloc->fOffset));
     if (err) {
         SkASSERT_RELEASE(heap->free(*alloc));
         return false;
     }
 
@@ skipping 22 matching lines @@
                                          VkImage image,
                                          bool linearTiling,
                                          GrVkAlloc* alloc) {
     const GrVkInterface* iface = gpu->vkInterface();
     VkDevice device = gpu->device();
 
     VkMemoryRequirements memReqs;
     GR_VK_CALL(iface, GetImageMemoryRequirements(device, image, &memReqs));
 
     uint32_t typeIndex = 0;
-    uint32_t heapIndex = 0;
     GrVkHeap* heap;
     const VkPhysicalDeviceMemoryProperties& phDevMemProps = gpu->physicalDeviceMemoryProperties();
     if (linearTiling) {
         VkMemoryPropertyFlags desiredMemProps = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
                                                 VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
         if (!get_valid_memory_type_index(phDevMemProps,
                                          memReqs.memoryTypeBits,
                                          desiredMemProps,
-                                         &typeIndex,
-                                         &heapIndex)) {
+                                         &typeIndex)) {
             // some sort of host-visible memory type should always be available
             SkASSERT_RELEASE(get_valid_memory_type_index(phDevMemProps,
                                                          memReqs.memoryTypeBits,
                                                          VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT,
-                                                         &typeIndex,
-                                                         &heapIndex));
+                                                         &typeIndex));
         }
         heap = gpu->getHeap(GrVkGpu::kLinearImage_Heap);
         VkMemoryPropertyFlags mpf = phDevMemProps.memoryTypes[typeIndex].propertyFlags;
         alloc->fFlags = mpf & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT ? 0x0
                                                                    : GrVkAlloc::kNoncoherent_Flag;
     } else {
         // this memory type should always be available
         SkASSERT_RELEASE(get_valid_memory_type_index(phDevMemProps,
                                                      memReqs.memoryTypeBits,
                                                      VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
-                                                     &typeIndex,
-                                                     &heapIndex));
+                                                     &typeIndex));
         if (memReqs.size <= kMaxSmallImageSize) {
             heap = gpu->getHeap(GrVkGpu::kSmallOptimalImage_Heap);
         } else {
             heap = gpu->getHeap(GrVkGpu::kOptimalImage_Heap);
         }
         alloc->fFlags = 0x0;
     }
 
-    if (!heap->alloc(memReqs.size, memReqs.alignment, typeIndex, heapIndex, alloc)) {
-        // if optimal, try to allocate from non-host-visible non-device-local memory instead
-        if (linearTiling ||
-            !get_valid_memory_type_index(phDevMemProps, memReqs.memoryTypeBits, 
-                                         0, &typeIndex, &heapIndex) ||
-            !heap->alloc(memReqs.size, memReqs.alignment, typeIndex, heapIndex, alloc)) {
-            SkDebugf("Failed to alloc image\n");
-            return false;
-        }
+    if (!heap->alloc(memReqs.size, memReqs.alignment, typeIndex, alloc)) {
+        SkDebugf("Failed to alloc image\n");
+        return false;
     }
 
     // Bind image
     VkResult err = GR_VK_CALL(iface, BindImageMemory(device, image,
                               alloc->fMemory, alloc->fOffset));
     if (err) {
         SkASSERT_RELEASE(heap->free(*alloc));
         return false;
     }
 
@@ skipping 245 matching lines @@
         Block* block = iter.get();
         if (largestSize < block->fSize) {
             largestSize = block->fSize;
         }
         iter.next();
     }
     SkASSERT(fLargestBlockSize == largestSize);
 #endif
 }
 
-GrVkSubHeap::GrVkSubHeap(const GrVkGpu* gpu, uint32_t memoryTypeIndex, uint32_t heapIndex,
+GrVkSubHeap::GrVkSubHeap(const GrVkGpu* gpu, uint32_t memoryTypeIndex,
                          VkDeviceSize size, VkDeviceSize alignment)
     : INHERITED(size, alignment)
     , fGpu(gpu)
-    , fMemoryTypeIndex(memoryTypeIndex)
-    , fHeapIndex(heapIndex) {
+    , 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();
-    } 
-#ifdef SK_DEBUG
-    else {
-        gHeapUsage[heapIndex] += size;
     }
-#endif
 }
 
 GrVkSubHeap::~GrVkSubHeap() {
     const GrVkInterface* iface = fGpu->vkInterface();
     GR_VK_CALL(iface, FreeMemory(fGpu->device(), fAlloc, nullptr));
-#ifdef SK_DEBUG
-    gHeapUsage[fHeapIndex] -= fSize;
-#endif
 }
 
 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, uint32_t heapIndex, GrVkAlloc* alloc) {
+                        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
-#ifdef SK_DEBUG
-        gHeapUsage[VK_MAX_MEMORY_HEAPS] += alignedSize;
-#endif
 
         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 &&
             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);
         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, heapIndex, fSubHeapSize, alignment));
+    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, heapIndex, alignedSize, 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,
-                           uint32_t memoryTypeIndex, uint32_t heapIndex, GrVkAlloc* alloc) {
+                           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]->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);
         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, heapIndex, alignedSize, alignment));
+    subHeap.reset(new GrVkSubHeap(fGpu, memoryTypeIndex, alignedSize, alignment));
     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;
 }