Create free list heap for suballocation

src/gpu/vk/GrVkGpu.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrVkGpu_DEFINED
 #define GrVkGpu_DEFINED
 
 #include "GrGpu.h"
 #include "GrGpuFactory.h"
 #include "vk/GrVkBackendContext.h"
 #include "GrVkCaps.h"
 #include "GrVkIndexBuffer.h"
+#include "GrVkMemory.h"
 #include "GrVkResourceProvider.h"
 #include "GrVkVertexBuffer.h"
 #include "GrVkUtil.h"
 
 #include "shaderc/shaderc.h"
 #include "vk/GrVkDefines.h"
 
 class GrPipeline;
 class GrNonInstancedMesh;
 
@@ skipping 89 matching lines @@
     shaderc_compiler_t shadercCompiler() const {
         return fCompiler;
     }
 
     void submitSecondaryCommandBuffer(const GrVkSecondaryCommandBuffer*);
 
     void finishDrawTarget() override;
 
     void generateMipmap(GrVkTexture* tex) const;
 
+    // Heaps
+    enum Heap {
+        kLinearImage_Heap = 0,
+        kOptimalImage_Heap,
+        kSmallOptimalImage_Heap,
+        kVertexBuffer_Heap,

[bsalomon, 2016/06/10 15:14:53]

Why separate index and vertex heaps? What's the optimal vs small optimal
distinction?

[jvanverth1, 2016/06/10 15:41:20]

I'll add some comments. In Vulkan, the index of the heap depends on the buffer
type. So in theory, a driver's implementation could have different heaps for
index and vertex buffers. The small vs. non-small distinction is to reduce
fragmentation in the texture heap. 

[jvanverth1, 2016/06/10 18:31:55]

As a side note, I'd like to incorporate the small-large distinction within the
heap (I think malloc does something similar), but would rather do that as a
separate change.

[jvanverth1, 2016/06/13 19:59:22]

Done.

+        kIndexBuffer_Heap,
+        kUniformBuffer_Heap,
+        kCopyReadBuffer_Heap,
+        kCopyWriteBuffer_Heap,
+
+        kLastHeap = kCopyWriteBuffer_Heap
+    };
+    static const int kHeapCount = kLastHeap + 1;
+
+    GrVkHeap* getHeap(Heap heap) const { return fHeaps[heap]; }
+
 private:
     GrVkGpu(GrContext* context, const GrContextOptions& options,
             const GrVkBackendContext* backendContext);
 
     void onResetContext(uint32_t resetBits) override {}
 
     GrTexture* onCreateTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
                                const SkTArray<GrMipLevel>&) override;
 
     GrTexture* onCreateCompressedTexture(const GrSurfaceDesc& desc, SkBudgeted,
@@ skipping 84 matching lines @@
     // They're copied here for convenient access.
     VkDevice                               fDevice;
     VkQueue                                fQueue;    // Must be Graphics queue
 
     // Created by GrVkGpu
     GrVkResourceProvider                   fResourceProvider;
     VkCommandPool                          fCmdPool;
     GrVkPrimaryCommandBuffer*              fCurrentCmdBuffer;
     VkPhysicalDeviceMemoryProperties       fPhysDevMemProps;
 
+    GrVkHeap*                             fHeaps[kHeapCount];
+
 #ifdef ENABLE_VK_LAYERS
     // For reporting validation layer errors
     VkDebugReportCallbackEXT               fCallback;
 #endif
 
     // Shaderc compiler used for compiling glsl in spirv. We only want to create the compiler once
     // since there is significant overhead to the first compile of any compiler.
     shaderc_compiler_t fCompiler;
 
 
     typedef GrGpu INHERITED;
 };
 
 #endif