Add DescriptorPool and set manager to GrVkProgram

src/gpu/vk/GrVkProgram.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 "GrVkProgram.h"
 
 #include "GrPipeline.h"
 #include "GrVkCommandBuffer.h"
 #include "GrVkDescriptorPool.h"
 #include "GrVkGpu.h"
 #include "GrVkImageView.h"
 #include "GrVkMemory.h"
 #include "GrVkPipeline.h"
 #include "GrVkSampler.h"
 #include "GrVkTexture.h"
 #include "GrVkUniformBuffer.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLXferProcessor.h"
 
 GrVkProgram::GrVkProgram(GrVkGpu* gpu,
                          GrVkPipeline* pipeline,
                          VkPipelineLayout layout,
                          VkDescriptorSetLayout dsLayout[2],
-                         GrVkDescriptorPool* descriptorPool,
-                         VkDescriptorSet descriptorSets[2],
                          const BuiltinUniformHandles& builtinUniformHandles,
                          const UniformInfoArray& uniforms,
                          uint32_t vertexUniformSize,
                          uint32_t fragmentUniformSize,
                          uint32_t numSamplers,
                          GrGLSLPrimitiveProcessor* geometryProcessor,
                          GrGLSLXferProcessor* xferProcessor,
                          const GrGLSLFragProcs& fragmentProcessors)
-    : fDescriptorPool(descriptorPool)
-    , fPipeline(pipeline)
+    : fPipeline(pipeline)
     , fPipelineLayout(layout)
     , fBuiltinUniformHandles(builtinUniformHandles)
     , fGeometryProcessor(geometryProcessor)
     , fXferProcessor(xferProcessor)
     , fFragmentProcessors(fragmentProcessors)
-    , fProgramDataManager(uniforms, vertexUniformSize, fragmentUniformSize) {
+    , fProgramDataManager(uniforms, vertexUniformSize, fragmentUniformSize)
+    , fSamplerPoolManager(dsLayout[GrVkUniformHandler::kSamplerDescSet],
+                          VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, numSamplers, gpu)
+    , fUniformPoolManager(dsLayout[GrVkUniformHandler::kUniformBufferDescSet],
+                          VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 2, gpu) {
     fSamplers.setReserve(numSamplers);
     fTextureViews.setReserve(numSamplers);
     fTextures.setReserve(numSamplers);
 
-    memcpy(fDSLayout, dsLayout, 2 * sizeof(VkDescriptorSetLayout));
-    memcpy(fDescriptorSets, descriptorSets, 2 * sizeof(VkDescriptorSetLayout));
+    fDescriptorSets[0] = VK_NULL_HANDLE;
+    fDescriptorSets[1] = VK_NULL_HANDLE;
+
+    // Currently we are always binding a descriptor set for uniform buffers.
+    fStartDS = GrVkUniformHandler::kUniformBufferDescSet;
+    fDSCount = 1;
+    if (numSamplers) {
+        fDSCount++;
+        fStartDS = SkTMin(fStartDS, (int)GrVkUniformHandler::kSamplerDescSet);
+    }
 
     fVertexUniformBuffer.reset(GrVkUniformBuffer::Create(gpu, vertexUniformSize, true));
     fFragmentUniformBuffer.reset(GrVkUniformBuffer::Create(gpu, fragmentUniformSize, true));
 
 #ifdef SK_DEBUG
     fNumSamplers = numSamplers;
 #endif
 }
 
 GrVkProgram::~GrVkProgram() {
     // Must of freed all GPU resources before this is destroyed
     SkASSERT(!fPipeline);
-    SkASSERT(!fDescriptorPool);
     SkASSERT(!fPipelineLayout);
-    SkASSERT(!fDSLayout[0]);
-    SkASSERT(!fDSLayout[1]);
     SkASSERT(!fSamplers.count());
     SkASSERT(!fTextureViews.count());
     SkASSERT(!fTextures.count());
 }
 
 void GrVkProgram::freeTempResources(const GrVkGpu* gpu) {
     for (int i = 0; i < fSamplers.count(); ++i) {
         fSamplers[i]->unref(gpu);
     }
     fSamplers.rewind();
 
     for (int i = 0; i < fTextureViews.count(); ++i) {
             fTextureViews[i]->unref(gpu);
     }
     fTextureViews.rewind();
 
     for (int i = 0; i < fTextures.count(); ++i) {
             fTextures[i]->unref(gpu);
     }
     fTextures.rewind();
 }
 
 void GrVkProgram::freeGPUResources(const GrVkGpu* gpu) {
     if (fPipeline) {
         fPipeline->unref(gpu);
         fPipeline = nullptr;
     }
-    if (fDescriptorPool) {
-        fDescriptorPool->unref(gpu);
-        fDescriptorPool = nullptr;
-    }
+
     if (fPipelineLayout) {
         GR_VK_CALL(gpu->vkInterface(), DestroyPipelineLayout(gpu->device(),
                                                              fPipelineLayout,
                                                              nullptr));
         fPipelineLayout = VK_NULL_HANDLE;
     }
 
-    if (fDSLayout[0]) {
-        GR_VK_CALL(gpu->vkInterface(), DestroyDescriptorSetLayout(gpu->device(), fDSLayout[0],
-                                                                  nullptr));
-        fDSLayout[0] = VK_NULL_HANDLE;
-    }
-    if (fDSLayout[1]) {
-        GR_VK_CALL(gpu->vkInterface(), DestroyDescriptorSetLayout(gpu->device(), fDSLayout[1],
-                                                                  nullptr));
-        fDSLayout[1] = VK_NULL_HANDLE;
-    }
-
     if (fVertexUniformBuffer) {
         fVertexUniformBuffer->release(gpu);
     }
 
     if (fFragmentUniformBuffer) {
         fFragmentUniformBuffer->release(gpu);
     }
+
+    fSamplerPoolManager.freeGPUResources(gpu);
+    fUniformPoolManager.freeGPUResources(gpu);
+
     this->freeTempResources(gpu);
 }
 
 void GrVkProgram::abandonGPUResources() {
     fPipeline->unrefAndAbandon();
     fPipeline = nullptr;
-    fDescriptorPool->unrefAndAbandon();
-    fDescriptorPool = nullptr;
+
     fPipelineLayout = VK_NULL_HANDLE;
-    fDSLayout[0] = VK_NULL_HANDLE;
-    fDSLayout[1] = 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();
 }
 
 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 18 matching lines @@
         const GrFragmentProcessor& processor = pipeline.getFragmentProcessor(i);
         fFragmentProcessors[i]->setData(fProgramDataManager, processor);
         fGeometryProcessor->setTransformData(primProc, fProgramDataManager, i,
                                              processor.coordTransforms());
         append_texture_bindings(processor, &textureBindings);
     }
 
     fXferProcessor->setData(fProgramDataManager, pipeline.getXferProcessor());
     append_texture_bindings(pipeline.getXferProcessor(), &textureBindings);
 
+    // Get new descriptor sets
+    if (fNumSamplers) {
+        fSamplerPoolManager.getNewDescriptorSet(gpu,
+                                             &fDescriptorSets[GrVkUniformHandler::kSamplerDescSet]);
+    }
+    fUniformPoolManager.getNewDescriptorSet(gpu,
+                                       &fDescriptorSets[GrVkUniformHandler::kUniformBufferDescSet]);
+
     this->writeUniformBuffers(gpu);
 
     this->writeSamplers(gpu, textureBindings);
 }
 
 void GrVkProgram::writeUniformBuffers(const GrVkGpu* gpu) {
     fProgramDataManager.uploadUniformBuffers(gpu, fVertexUniformBuffer, fFragmentUniformBuffer);
 
     VkWriteDescriptorSet descriptorWrites[2];
     memset(descriptorWrites, 0, 2 * sizeof(VkWriteDescriptorSet));
@@ skipping 132 matching lines @@
         fRenderTargetState.fRenderTargetOrigin = rt->origin();
 
         float rtAdjustmentVec[4];
         fRenderTargetState.getRTAdjustmentVec(rtAdjustmentVec);
         fProgramDataManager.set4fv(fBuiltinUniformHandles.fRTAdjustmentUni, 1, rtAdjustmentVec);
     }
 }
 
 void GrVkProgram::bind(const GrVkGpu* gpu, GrVkCommandBuffer* commandBuffer) {
     commandBuffer->bindPipeline(gpu, fPipeline);
-    commandBuffer->bindDescriptorSets(gpu, this, fPipelineLayout, 0, 2, fDescriptorSets, 0,
-                                      nullptr);
+
+    if (fDSCount) {
+        commandBuffer->bindDescriptorSets(gpu, this, fPipelineLayout, fStartDS, fDSCount,
+                                          &fDescriptorSets[fStartDS], 0, nullptr);
+    }
 }
 
 void GrVkProgram::addUniformResources(GrVkCommandBuffer& commandBuffer) {
-#if 1
-    commandBuffer.addResource(fDescriptorPool);
+    if (fSamplerPoolManager.fPool) {
+        commandBuffer.addResource(fSamplerPoolManager.fPool);
+    }
+    if (fUniformPoolManager.fPool) {
+        commandBuffer.addResource(fUniformPoolManager.fPool);
+    }
+
     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]);
     }
 
     for (int i = 0; i < fTextureViews.count(); ++i) {
         commandBuffer.addResource(fTextureViews[i]);
     }
 
     for (int i = 0; i < fTextures.count(); ++i) {
         commandBuffer.addResource(fTextures[i]);
     }
-#endif
 }
+
+////////////////////////////////////////////////////////////////////////////////
+
+void GrVkProgram::DescriptorPoolManager::getNewPool(GrVkGpu* gpu) {
+    if (fPool) {
+        fPool->unref(gpu);
+        SkASSERT(fMaxDescriptorSets < (SK_MaxU32 >> 1));
+        fMaxDescriptorSets = fMaxDescriptorSets << 1;
+
+    }
+    if (fMaxDescriptorSets) {
+        fPool = gpu->resourceProvider().findOrCreateCompatibleDescriptorPool(fDescType,
+                                                                             fMaxDescriptorSets);
+    }
+    SkASSERT(fPool || !fMaxDescriptorSets);
+}
+
+void GrVkProgram::DescriptorPoolManager::getNewDescriptorSet(GrVkGpu* gpu, VkDescriptorSet* ds) {
+    if (!fMaxDescriptorSets) {
+        return;
+    }
+    if (fCurrentDescriptorSet == fMaxDescriptorSets) {
+        this->getNewPool(gpu);
+        fCurrentDescriptorSet = 0;
+    }
+    fCurrentDescriptorSet++;
+
+    VkDescriptorSetAllocateInfo dsAllocateInfo;
+    memset(&dsAllocateInfo, 0, sizeof(VkDescriptorSetAllocateInfo));
+    dsAllocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+    dsAllocateInfo.pNext = nullptr;
+    dsAllocateInfo.descriptorPool = fPool->descPool();
+    dsAllocateInfo.descriptorSetCount = 1;
+    dsAllocateInfo.pSetLayouts = &fDescLayout;
+
+    GR_VK_CALL_ERRCHECK(gpu->vkInterface(), AllocateDescriptorSets(gpu->device(),
+                                                                   &dsAllocateInfo,
+                                                                   ds));
+}
+
+void GrVkProgram::DescriptorPoolManager::freeGPUResources(const GrVkGpu* gpu) {
+    if (fDescLayout) {
+        GR_VK_CALL(gpu->vkInterface(), DestroyDescriptorSetLayout(gpu->device(), fDescLayout,
+                                                                  nullptr));
+        fDescLayout = VK_NULL_HANDLE;
+    }
+
+    if (fPool) {
+        fPool->unref(gpu);
+        fPool = nullptr;
+    }
+}
+
+void GrVkProgram::DescriptorPoolManager::abandonGPUResources() {
+    fDescLayout = VK_NULL_HANDLE;
+    if (fPool) {
+        fPool->unrefAndAbandon();
+        fPool = nullptr;
+    }
+}