Create free list heap for suballocation

src/gpu/vk/GrVkBuffer.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 "GrVkBuffer.h"
 #include "GrVkGpu.h"
 #include "GrVkMemory.h"
@@ skipping 38 matching lines @@
     bufInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
     bufInfo.queueFamilyIndexCount = 0;
     bufInfo.pQueueFamilyIndices = nullptr;
 
     VkResult err;
     err = VK_CALL(gpu, CreateBuffer(gpu->device(), &bufInfo, nullptr, &buffer));
     if (err) {
         return nullptr;
     }
 
-    VkMemoryPropertyFlags requiredMemProps = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
-                                             VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
-                                             VK_MEMORY_PROPERTY_HOST_CACHED_BIT;
-
     if (!GrVkMemory::AllocAndBindBufferMemory(gpu,
                                               buffer,
-                                              requiredMemProps,
+                                              desc.fType,
                                               &alloc)) {
-        // Try again without requiring host cached memory
-        requiredMemProps = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
-                           VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
-        if (!GrVkMemory::AllocAndBindBufferMemory(gpu,
-                                                  buffer,
-                                                  requiredMemProps,
-                                                  &alloc)) {
-            VK_CALL(gpu, DestroyBuffer(gpu->device(), buffer, nullptr));
-            return nullptr;
-        }
+        return nullptr;
     }
 
-    const GrVkBuffer::Resource* resource = new GrVkBuffer::Resource(buffer, alloc);
+    const GrVkBuffer::Resource* resource = new GrVkBuffer::Resource(buffer, alloc, desc.fType);
     if (!resource) {
         VK_CALL(gpu, DestroyBuffer(gpu->device(), buffer, nullptr));
-        GrVkMemory::FreeBufferMemory(gpu, alloc);
+        GrVkMemory::FreeBufferMemory(gpu, desc.fType, alloc);
         return nullptr;
     }
 
     return resource;
 }
 
-
 void GrVkBuffer::addMemoryBarrier(const GrVkGpu* gpu,
                                   VkAccessFlags srcAccessMask,
                                   VkAccessFlags dstAccesMask,
                                   VkPipelineStageFlags srcStageMask,
                                   VkPipelineStageFlags dstStageMask,
                                   bool byRegion) const {
     VkBufferMemoryBarrier bufferMemoryBarrier = {
         VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // sType
         NULL,                                    // pNext
         srcAccessMask,                           // srcAccessMask
         dstAccesMask,                            // dstAccessMask
         VK_QUEUE_FAMILY_IGNORED,                 // srcQueueFamilyIndex
         VK_QUEUE_FAMILY_IGNORED,                 // dstQueueFamilyIndex
         this->buffer(),                          // buffer
         0,                                       // offset
         fDesc.fSizeInBytes,                      // size
     };
 
     // TODO: restrict to area of buffer we're interested in
     gpu->addBufferMemoryBarrier(srcStageMask, dstStageMask, byRegion, &bufferMemoryBarrier);
 }
 
 void GrVkBuffer::Resource::freeGPUData(const GrVkGpu* gpu) const {
     SkASSERT(fBuffer);
     SkASSERT(fAlloc.fMemory);
     VK_CALL(gpu, DestroyBuffer(gpu->device(), fBuffer, nullptr));
-    GrVkMemory::FreeBufferMemory(gpu, fAlloc);
+    GrVkMemory::FreeBufferMemory(gpu, fType, fAlloc);
 }
 
 void GrVkBuffer::vkRelease(const GrVkGpu* gpu) {
     VALIDATE();
     fResource->unref(gpu);
     fResource = nullptr;
     fMapPtr = nullptr;
     VALIDATE();
 }
 
@@ skipping 70 matching lines @@
     VK_CALL(gpu, UnmapMemory(gpu->device(), alloc.fMemory));
 
     return true;
 }
 
 void GrVkBuffer::validate() const {
     SkASSERT(!fResource || kVertex_Type == fDesc.fType || kIndex_Type == fDesc.fType
              || kCopyRead_Type == fDesc.fType || kCopyWrite_Type == fDesc.fType
              || kUniform_Type == fDesc.fType);
 }