Unify DescriptorPools for vulkan uniform descriptor sets

src/gpu/vk/GrVkPipelineState.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 "GrVkPipelineState.h"
 
 #include "GrPipeline.h"
@@ skipping 10 matching lines @@
 #include "GrVkUniformBuffer.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLXferProcessor.h"
 #include "SkMipmap.h"
 
 GrVkPipelineState::GrVkPipelineState(GrVkGpu* gpu,
                                      const GrVkPipelineState::Desc& desc,
                                      GrVkPipeline* pipeline,
                                      VkPipelineLayout layout,
-                                     VkDescriptorSetLayout dsLayout[2],
+                                     VkDescriptorSetLayout dsSamplerLayout,
                                      const BuiltinUniformHandles& builtinUniformHandles,
                                      const UniformInfoArray& uniforms,
                                      uint32_t vertexUniformSize,
                                      uint32_t fragmentUniformSize,
                                      uint32_t numSamplers,
                                      GrGLSLPrimitiveProcessor* geometryProcessor,
                                      GrGLSLXferProcessor* xferProcessor,
                                      const GrGLSLFragProcs& fragmentProcessors)
     : fPipeline(pipeline)
     , fPipelineLayout(layout)
     , fStartDS(SK_MaxS32)
     , fDSCount(0)
     , fBuiltinUniformHandles(builtinUniformHandles)
     , fGeometryProcessor(geometryProcessor)
     , fXferProcessor(xferProcessor)
     , fFragmentProcessors(fragmentProcessors)
     , fDesc(desc)
     , fDataManager(uniforms, vertexUniformSize, fragmentUniformSize)
-    , fSamplerPoolManager(dsLayout[GrVkUniformHandler::kSamplerDescSet],
-                          VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, numSamplers, gpu)
-    , fUniformPoolManager(dsLayout[GrVkUniformHandler::kUniformBufferDescSet],
-                          VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
-                          (vertexUniformSize || fragmentUniformSize) ? 2 : 0, gpu) {
+    , fSamplerPoolManager(dsSamplerLayout, VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
+                          numSamplers, gpu)
+    , fCurrentUniformDescPool(nullptr) {
     fSamplers.setReserve(numSamplers);
     fTextureViews.setReserve(numSamplers);
     fTextures.setReserve(numSamplers);
 
     fDescriptorSets[0] = VK_NULL_HANDLE;
     fDescriptorSets[1] = VK_NULL_HANDLE;
 
     // Currently we are always binding a descriptor set for uniform buffers.
     if (vertexUniformSize || fragmentUniformSize) {
         fDSCount++;
@@ skipping 54 matching lines @@
 
     if (fVertexUniformBuffer) {
         fVertexUniformBuffer->release(gpu);
     }
 
     if (fFragmentUniformBuffer) {
         fFragmentUniformBuffer->release(gpu);
     }
 
     fSamplerPoolManager.freeGPUResources(gpu);
-    fUniformPoolManager.freeGPUResources(gpu);
+    if (fCurrentUniformDescPool) {
+        fCurrentUniformDescPool->unref(gpu);
+        fCurrentUniformDescPool = nullptr;
+    }
 
     this->freeTempResources(gpu);
 }
 
 void GrVkPipelineState::abandonGPUResources() {
     fPipeline->unrefAndAbandon();
     fPipeline = nullptr;
 
     fPipelineLayout = VK_NULL_HANDLE;
 
     fVertexUniformBuffer->abandon();
     fFragmentUniformBuffer->abandon();
 
     for (int i = 0; i < fSamplers.count(); ++i) {
         fSamplers[i]->unrefAndAbandon();
     }
     fSamplers.rewind();
 
     for (int i = 0; i < fTextureViews.count(); ++i) {
         fTextureViews[i]->unrefAndAbandon();
     }
     fTextureViews.rewind();
 
     for (int i = 0; i < fTextures.count(); ++i) {
         fTextures[i]->unrefAndAbandon();
     }
     fTextures.rewind();
 
     fSamplerPoolManager.abandonGPUResources();
-    fUniformPoolManager.abandonGPUResources();
+    if (fCurrentUniformDescPool) {
+        fCurrentUniformDescPool->unrefAndAbandon();
+        fCurrentUniformDescPool = nullptr;
+    }
 }
 
 static void append_texture_bindings(const GrProcessor& processor,
                                     SkTArray<const GrTextureAccess*>* textureBindings) {
     if (int numTextures = processor.numTextures()) {
         const GrTextureAccess** bindings = textureBindings->push_back_n(numTextures);
         int i = 0;
         do {
             bindings[i] = &processor.textureAccess(i);
         } while (++i < numTextures);
@@ skipping 28 matching lines @@
     // Get new descriptor sets
     if (fNumSamplers) {
         fSamplerPoolManager.getNewDescriptorSet(gpu,
                                              &fDescriptorSets[GrVkUniformHandler::kSamplerDescSet]);
         this->writeSamplers(gpu, textureBindings);
     }
 
     if (fVertexUniformBuffer.get() || fFragmentUniformBuffer.get()) {
         if (fDataManager.uploadUniformBuffers(gpu, fVertexUniformBuffer, fFragmentUniformBuffer) ||
             VK_NULL_HANDLE == fDescriptorSets[GrVkUniformHandler::kUniformBufferDescSet]) {
-            fUniformPoolManager.getNewDescriptorSet(gpu,
-                                       &fDescriptorSets[GrVkUniformHandler::kUniformBufferDescSet]);
+            const GrVkDescriptorPool* pool;
+            int uniformDSIdx = GrVkUniformHandler::kUniformBufferDescSet;
+            gpu->resourceProvider().getUniformDescriptorSet(&fDescriptorSets[uniformDSIdx],
+                                                            &pool);
+            if (pool != fCurrentUniformDescPool) {
+                if (fCurrentUniformDescPool) {
+                    fCurrentUniformDescPool->unref(gpu);
+                }
+                fCurrentUniformDescPool = pool;
+                fCurrentUniformDescPool->ref();
+            }
             this->writeUniformBuffers(gpu);
         }
     }
 }
 
 void GrVkPipelineState::writeUniformBuffers(const GrVkGpu* gpu) {
     VkWriteDescriptorSet descriptorWrites[2];
     memset(descriptorWrites, 0, 2 * sizeof(VkWriteDescriptorSet));
 
     uint32_t firstUniformWrite = 0;
@@ skipping 149 matching lines @@
     if (fDSCount) {
         commandBuffer->bindDescriptorSets(gpu, this, fPipelineLayout, fStartDS, fDSCount,
                                           &fDescriptorSets[fStartDS], 0, nullptr);
     }
 }
 
 void GrVkPipelineState::addUniformResources(GrVkCommandBuffer& commandBuffer) {
     if (fSamplerPoolManager.fPool) {
         commandBuffer.addResource(fSamplerPoolManager.fPool);
     }
-    if (fUniformPoolManager.fPool) {
-        commandBuffer.addResource(fUniformPoolManager.fPool);
+    if (fCurrentUniformDescPool) {
+        commandBuffer.addResource(fCurrentUniformDescPool);
     }
 
     if (fVertexUniformBuffer.get()) {
         commandBuffer.addResource(fVertexUniformBuffer->resource());
     }
     if (fFragmentUniformBuffer.get()) {
         commandBuffer.addResource(fFragmentUniformBuffer->resource());
     }
     for (int i = 0; i < fSamplers.count(); ++i) {
         commandBuffer.addResource(fSamplers[i]);
@@ skipping 20 matching lines @@
         }
 
     }
     if (fMaxDescriptors) {
         fPool = gpu->resourceProvider().findOrCreateCompatibleDescriptorPool(fDescType,
                                                                              fMaxDescriptors);
     }
     SkASSERT(fPool || !fMaxDescriptors);
 }
 
-void GrVkPipelineState::DescriptorPoolManager::getNewDescriptorSet(GrVkGpu* gpu, VkDescriptorSet* ds) {
+void GrVkPipelineState::DescriptorPoolManager::getNewDescriptorSet(GrVkGpu* gpu,
+                                                                   VkDescriptorSet* ds) {
     if (!fMaxDescriptors) {
         return;
     }
     fCurrentDescriptorCount += fDescCountPerSet;
     if (fCurrentDescriptorCount > fMaxDescriptors) {
         this->getNewPool(gpu);
         fCurrentDescriptorCount = fDescCountPerSet;
     }
 
     VkDescriptorSetAllocateInfo dsAllocateInfo;
@@ skipping 64 matching lines @@
 
     b.add32(get_blend_info_key(pipeline));
 
     b.add32(primitiveType);
 
     // Set key length
     int keyLength = key->count();
     SkASSERT(0 == (keyLength % 4));
     *reinterpret_cast<uint32_t*>(key->begin()) = SkToU32(keyLength);
 }