Reuse sampler descriptor set allocations in Vulkan

src/gpu/vk/GrVkResourceProvider.h

 /*
 * Copyright 2016 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #ifndef GrVkResourceProvider_DEFINED
 #define GrVkResourceProvider_DEFINED
 
@@ skipping 14 matching lines @@
 
 class GrPipeline;
 class GrPrimitiveProcessor;
 class GrTextureParams;
 class GrVkGpu;
 class GrVkPipeline;
 class GrVkPrimaryCommandBuffer;
 class GrVkRenderTarget;
 class GrVkSampler;
 class GrVkSecondaryCommandBuffer;
+class GrVkUniformHandler;
 
 class GrVkResourceProvider {
 public:
     GrVkResourceProvider(GrVkGpu* gpu);
     ~GrVkResourceProvider();
 
     // Set up any initial vk objects
     void init();
 
     GrVkPipeline* createPipeline(const GrPipeline& pipeline,
@@ skipping 49 matching lines @@
 
     // Finds or creates a compatible GrVkSampler based on the GrTextureParams.
     // The refcount is incremented and a pointer returned.
     GrVkSampler* findOrCreateCompatibleSampler(const GrTextureParams&, uint32_t mipLevels);
 
     sk_sp<GrVkPipelineState> findOrCreateCompatiblePipelineState(const GrPipeline&,
                                                                  const GrPrimitiveProcessor&,
                                                                  GrPrimitiveType,
                                                                  const GrVkRenderPass& renderPass);
 
-    // Returns a handle which the GrVkResourceProvider uses to know which compatible
-    // GrVkDescriptorSetManager to use when getting or recycling a GrVkDescriptorSet. Passing in a
-    // value of 0 for numSamplers is used to signal this is for the uniform descriptor set.
-    void getDescSetHandle(uint32_t numSamplers, VkDescriptorSetLayout layout,
-                          GrVkDescriptorSetManager::Handle* handle);
+    void getSamplerDescriptorSetHandle(const GrVkUniformHandler&,
+                                       GrVkDescriptorSetManager::Handle* handle);
+
+    // Returns the compatible VkDescriptorSetLayout to use for uniform buffers. The caller does not
+    // own the VkDescriptorSetLayout and thus should not delete it. This function should be used
+    // when the caller needs the layout to create a VkPipelineLayout.
+    VkDescriptorSetLayout getUniformDSLayout() const;
+
+    // Returns the compatible VkDescriptorSetLayout to use for a specific sampler handle. The caller
+    // does not own the VkDescriptorSetLayout and thus should not delete it. This function should be
+    // used when the caller needs the layout to create a VkPipelineLayout.
+    VkDescriptorSetLayout getSamplerDSLayout(const GrVkDescriptorSetManager::Handle&) const;
 
     // Returns a GrVkDescriptorSet that can be used for uniform buffers. The GrVkDescriptorSet
     // is already reffed for the caller.
     const GrVkDescriptorSet* getUniformDescriptorSet();
 
     // Returns a GrVkDescriptorSet that can be used for sampler descriptors that are compatible with
-    // the GrVkDescriptorSetManager::Handle passed int.. The GrVkDescriptorSet is already reffed for
+    // the GrVkDescriptorSetManager::Handle passed in. The GrVkDescriptorSet is already reffed for
     // the caller.
-    // TODO: Move samplers in GrVkPipelineState to use the GrVkResourceProvider to allocate
-    // descriptor sets from.
     const GrVkDescriptorSet* getSamplerDescriptorSet(const GrVkDescriptorSetManager::Handle&);
 
-    // Returns the compatible VkDescriptorSetLayout to use for uniform buffers. The caller does not
-    // own the VkDescriptorSetLayout and thus should not delete it. This function should be used
-    // when the caller needs the layout to create a VkPipelineLayout.
-    VkDescriptorSetLayout getUniDSLayout() const { return fUniformDescLayout; }
 
     // Signals that the descriptor set passed it, which is compatible with the passed in handle,
     // can be reused by the next allocation request.
     void recycleDescriptorSet(const GrVkDescriptorSet* descSet,
                               const GrVkDescriptorSetManager::Handle&);
 
     // Creates or finds free uniform buffer resources of size GrVkUniformBuffer::kStandardSize.
     // Anything larger will need to be created and released by the client.
     const GrVkResource* findOrCreateStandardUniformBufferResource();
 
@@ skipping 74 matching lines @@
                                       const GrVkRenderPass::LoadStoreOps& stencilOps);
 
         void releaseResources(const GrVkGpu* gpu);
         void abandonResources();
 
     private:
         SkSTArray<4, GrVkRenderPass*> fRenderPasses;
         int                           fLastReturnedIndex;
     };
 
-    // Initialiaze the vkDescriptorSetLayout used for allocating new uniform buffer descritpor sets.
-    void initUniformDescObjects();
-
     GrVkGpu* fGpu;
 
     // Central cache for creating pipelines
     VkPipelineCache fPipelineCache;
 
     SkSTArray<4, CompatibleRenderPassSet> fRenderPassArray;
 
     // Array of PrimaryCommandBuffers that are currently in flight
-    SkSTArray<4, GrVkPrimaryCommandBuffer*> fActiveCommandBuffers;
+    SkSTArray<4, GrVkPrimaryCommandBuffer*, true> fActiveCommandBuffers;
     // Array of available primary command buffers that are not in flight
-    SkSTArray<4, GrVkPrimaryCommandBuffer*> fAvailableCommandBuffers;
+    SkSTArray<4, GrVkPrimaryCommandBuffer*, true> fAvailableCommandBuffers;
 
     // Array of available secondary command buffers
-    SkSTArray<16, GrVkSecondaryCommandBuffer*> fAvailableSecondaryCommandBuffers;
+    SkSTArray<16, GrVkSecondaryCommandBuffer*, true> fAvailableSecondaryCommandBuffers;
 
     // Array of available uniform buffer resources
-    SkSTArray<16, const GrVkResource*> fAvailableUniformBufferResources;
+    SkSTArray<16, const GrVkResource*, true> fAvailableUniformBufferResources;
 
     // Stores GrVkSampler objects that we've already created so we can reuse them across multiple
     // GrVkPipelineStates
     SkTDynamicHash<GrVkSampler, uint16_t> fSamplers;
 
     // Cache of GrVkPipelineStates
     PipelineStateCache* fPipelineStateCache;
 
-    SkSTArray<4, GrVkDescriptorSetManager> fDescriptorSetManagers;
+    SkSTArray<4, GrVkDescriptorSetManager, true> fDescriptorSetManagers;
 
-    GrVkDescriptorSetManager::Handle       fUniformDSHandle;
-
-    // Current pool to allocate uniform descriptor sets from
-    VkDescriptorSetLayout  fUniformDescLayout;
-    //Curent number of uniform descriptors allocated from the pool
-    int                fCurrentUniformDescCount;
-    int                fCurrMaxUniDescriptors;
-
-    enum {
-        kMaxUniformDescriptors = 1024,
-        kNumUniformDescPerSet = 2,
-        kStartNumUniformDescriptors = 16, // must be less than kMaxUniformDescriptors
-    };
+    GrVkDescriptorSetManager::Handle fUniformDSHandle;
 };
 
 #endif