Setup system in Vulkan to reuse VkDescriptorSet allocations.

src/gpu/vk/GrVkResourceProvider.cpp

 /*
 * Copyright 2016 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #include "GrVkResourceProvider.h"
 
 #include "GrTextureParams.h"
 #include "GrVkCommandBuffer.h"
 #include "GrVkPipeline.h"
 #include "GrVkRenderTarget.h"
 #include "GrVkSampler.h"
 #include "GrVkUtil.h"
 
 #ifdef SK_TRACE_VK_RESOURCES
 GrVkResource::Trace GrVkResource::fTrace;
 uint32_t GrVkResource::fKeyCounter = 0;
 #endif
 
 GrVkResourceProvider::GrVkResourceProvider(GrVkGpu* gpu)
     : fGpu(gpu)
     , fPipelineCache(VK_NULL_HANDLE)
-    , fUniformDescPool(nullptr)
     , fCurrentUniformDescCount(0) {
     fPipelineStateCache = new PipelineStateCache(gpu);
 }
 
 GrVkResourceProvider::~GrVkResourceProvider() {
     SkASSERT(0 == fRenderPassArray.count());
     SkASSERT(VK_NULL_HANDLE == fPipelineCache);
     delete fPipelineStateCache;
 }
 
@@ skipping 18 matching lines @@
     dsUniformLayoutCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
     dsUniformLayoutCreateInfo.pNext = nullptr;
     dsUniformLayoutCreateInfo.flags = 0;
     dsUniformLayoutCreateInfo.bindingCount = 2;
     dsUniformLayoutCreateInfo.pBindings = dsUniBindings;
 
     GR_VK_CALL_ERRCHECK(fGpu->vkInterface(), CreateDescriptorSetLayout(fGpu->device(),
                                                                        &dsUniformLayoutCreateInfo,
                                                                        nullptr,
                                                                        &fUniformDescLayout));
-    fCurrMaxUniDescriptors = kStartNumUniformDescriptors;
-    fUniformDescPool = this->findOrCreateCompatibleDescriptorPool(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-                                                                  fCurrMaxUniDescriptors);
+
+    this->getDescSetHandle(0, fUniformDescLayout, &fUniformDSHandle);
 }
 
 void GrVkResourceProvider::init() {
     VkPipelineCacheCreateInfo createInfo;
     memset(&createInfo, 0, sizeof(VkPipelineCacheCreateInfo));
     createInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
     createInfo.pNext = nullptr;
     createInfo.flags = 0;
     createInfo.initialDataSize = 0;
     createInfo.pInitialData = nullptr;
@@ skipping 107 matching lines @@
 }
 
 sk_sp<GrVkPipelineState> GrVkResourceProvider::findOrCreateCompatiblePipelineState(
                                                                  const GrPipeline& pipeline,
                                                                  const GrPrimitiveProcessor& proc,
                                                                  GrPrimitiveType primitiveType,
                                                                  const GrVkRenderPass& renderPass) {
     return fPipelineStateCache->refPipelineState(pipeline, proc, primitiveType, renderPass);
 }
 
-void GrVkResourceProvider::getUniformDescriptorSet(VkDescriptorSet* ds,
-                                                   const GrVkDescriptorPool** outPool) {
-    fCurrentUniformDescCount += kNumUniformDescPerSet;
-    if (fCurrentUniformDescCount > fCurrMaxUniDescriptors) {
-        fUniformDescPool->unref(fGpu);
-        uint32_t newPoolSize = fCurrMaxUniDescriptors + ((fCurrMaxUniDescriptors + 1) >> 1);
-        if (newPoolSize < kMaxUniformDescriptors) {
-            fCurrMaxUniDescriptors = newPoolSize;
-        } else {
-            fCurrMaxUniDescriptors = kMaxUniformDescriptors;
+
+void GrVkResourceProvider::getDescSetHandle(uint32_t numSamplers, VkDescriptorSetLayout layout,
+                                            GrVkDescriptorSetManager::Handle* handle) {
+    SkASSERT(handle);
+    for (int i = 0; i < fDescriptorSetManagers.count(); ++i) {
+        if (fDescriptorSetManagers[i].isCompatible(numSamplers)) {
+           *handle = GrVkDescriptorSetManager::Handle(i);
+           return;
         }
-        fUniformDescPool =
-            this->findOrCreateCompatibleDescriptorPool(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-                                                       fCurrMaxUniDescriptors);
-        fCurrentUniformDescCount = kNumUniformDescPerSet;
     }
-    SkASSERT(fUniformDescPool);
 
-    VkDescriptorSetAllocateInfo dsAllocateInfo;
-    memset(&dsAllocateInfo, 0, sizeof(VkDescriptorSetAllocateInfo));
-    dsAllocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
-    dsAllocateInfo.pNext = nullptr;
-    dsAllocateInfo.descriptorPool = fUniformDescPool->descPool();
-    dsAllocateInfo.descriptorSetCount = 1;
-    dsAllocateInfo.pSetLayouts = &fUniformDescLayout;
-    GR_VK_CALL_ERRCHECK(fGpu->vkInterface(), AllocateDescriptorSets(fGpu->device(),
-                                                                    &dsAllocateInfo,
-                                                                    ds));
-    *outPool = fUniformDescPool;
+    // Failed to find a DescSetManager, we must create a new one;
+    VkDescriptorType type = numSamplers ? VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER
+                                        : VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
+
+    fDescriptorSetManagers.emplace_back(fGpu, layout, type, numSamplers);
+    *handle = GrVkDescriptorSetManager::Handle(fDescriptorSetManagers.count() - 1);
+}
+
+const GrVkDescriptorSet* GrVkResourceProvider::getUniformDescriptorSet() {
+    SkASSERT(fUniformDSHandle.isValid());
+    return fDescriptorSetManagers[fUniformDSHandle.toIndex()].getDescriptorSet(fGpu,
+                                                                               fUniformDSHandle);
+}
+
+
+void GrVkResourceProvider::recycleDescriptorSet(const GrVkDescriptorSet* descSet,
+                                                const GrVkDescriptorSetManager::Handle& handle) {
+    SkASSERT(descSet);
+    SkASSERT(handle.isValid());
+    int managerIdx = handle.toIndex();
+    SkASSERT(managerIdx < fDescriptorSetManagers.count());
+    fDescriptorSetManagers[managerIdx].recycleDescriptorSet(descSet);
 }
 
 GrVkPrimaryCommandBuffer* GrVkResourceProvider::findOrCreatePrimaryCommandBuffer() {
     GrVkPrimaryCommandBuffer* cmdBuffer = nullptr;
     int count = fAvailableCommandBuffers.count();
     if (count > 0) {
-        cmdBuffer = fAvailableCommandBuffers[count -1];
+        cmdBuffer = fAvailableCommandBuffers[count - 1];
         SkASSERT(cmdBuffer->finished(fGpu));
         fAvailableCommandBuffers.removeShuffle(count - 1);
     } else {
         cmdBuffer = GrVkPrimaryCommandBuffer::Create(fGpu, fGpu->cmdPool());
     }
     fActiveCommandBuffers.push_back(cmdBuffer);
     cmdBuffer->ref();
     return cmdBuffer;
 }
 
@@ skipping 66 matching lines @@
 
     GR_VK_CALL(fGpu->vkInterface(), DestroyPipelineCache(fGpu->device(), fPipelineCache, nullptr));
     fPipelineCache = VK_NULL_HANDLE;
 
     if (fUniformDescLayout) {
         GR_VK_CALL(fGpu->vkInterface(), DestroyDescriptorSetLayout(fGpu->device(),
                                                                    fUniformDescLayout,
                                                                    nullptr));
         fUniformDescLayout = VK_NULL_HANDLE;
     }
-    fUniformDescPool->unref(fGpu);
+
+    // We must release/destroy all command buffers and pipeline states before releasing the
+    // GrVkDescriptorSetManagers
+    for (int i = 0; i < fDescriptorSetManagers.count(); ++i) {
+        fDescriptorSetManagers[i].release(fGpu);
+    }
+    fDescriptorSetManagers.reset();
 }
 
 void GrVkResourceProvider::abandonResources() {
     // release our active command buffers
     for (int i = 0; i < fActiveCommandBuffers.count(); ++i) {
         SkASSERT(fActiveCommandBuffers[i]->finished(fGpu));
         SkASSERT(fActiveCommandBuffers[i]->unique());
         fActiveCommandBuffers[i]->unrefAndAbandon();
     }
     fActiveCommandBuffers.reset();
@@ skipping 22 matching lines @@
     SkTDynamicHash<GrVkSampler, uint16_t>::Iter iter(&fSamplers);
     for (; !iter.done(); ++iter) {
         (*iter).unrefAndAbandon();
     }
     fSamplers.reset();
 
     fPipelineStateCache->abandon();
 
     fPipelineCache = VK_NULL_HANDLE;
 
-    fUniformDescLayout = VK_NULL_HANDLE;
-    fUniformDescPool->unrefAndAbandon();
+    // We must abandon all command buffers and pipeline states before abandoning the
+    // GrVkDescriptorSetManagers
+    for (int i = 0; i < fDescriptorSetManagers.count(); ++i) {
+        fDescriptorSetManagers[i].abandon();
+    }
+    fDescriptorSetManagers.reset();
+
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrVkResourceProvider::CompatibleRenderPassSet::CompatibleRenderPassSet(
                                                                      const GrVkGpu* gpu,
                                                                      const GrVkRenderTarget& target)
     : fLastReturnedIndex(0) {
     fRenderPasses.emplace_back(new GrVkRenderPass());
     fRenderPasses[0]->initSimple(gpu, target);
@@ skipping 35 matching lines @@
 }
 
 void GrVkResourceProvider::CompatibleRenderPassSet::abandonResources() {
     for (int i = 0; i < fRenderPasses.count(); ++i) {
         if (fRenderPasses[i]) {
             fRenderPasses[i]->unrefAndAbandon();
             fRenderPasses[i] = nullptr;
         }
     }
 }