Setup system in Vulkan to reuse VkDescriptorSet allocations.

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
 
 #include "GrGpu.h"
 #include "GrResourceHandle.h"
 #include "GrVkDescriptorPool.h"
+#include "GrVkDescriptorSetManager.h"
 #include "GrVkPipelineState.h"
 #include "GrVkRenderPass.h"
 #include "GrVkResource.h"
 #include "GrVkUtil.h"
 #include "SkTArray.h"
 #include "SkTDynamicHash.h"
 #include "SkTHash.h"
 #include "SkTInternalLList.h"
 
 #include "vk/GrVkDefines.h"
@@ skipping 69 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);
 
-    // For all our GrVkPipelineState objects, we require a layout where the first set contains two
-    // uniform buffers, one for the vertex shader and one for the fragment shader. Thus it is
-    // possible for us to use a shadered descriptor pool to allocate all these similar descriptor
-    // sets. The caller is responsible for reffing the outPool for as long as the returned
-    // VkDescriptor set is in use.
-    void getUniformDescriptorSet(VkDescriptorSet*, const GrVkDescriptorPool** outPool);
+    // 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);
+
+    // 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 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&);
+
     // Destroy any cached resources. To be called before destroying the VkDevice.
     // The assumption is that all queues are idle and all command buffers are finished.
     // For resource tracing to work properly, this should be called after unrefing all other
     // resource usages.
     void destroyResources();
 
     // Abandon any cached resources. To be used when the context/VkDevice is lost.
     // For resource tracing to work properly, this should be called after unrefing all other
     // resource usages.
     void abandonResources();
@@ skipping 31 matching lines @@
         SkTInternalLList<Entry> fLRUList;
 
         GrVkGpu*                    fGpu;
 
 #ifdef GR_PIPELINE_STATE_CACHE_STATS
         int                         fTotalRequests;
         int                         fCacheMisses;
 #endif
     };
 
-
     class CompatibleRenderPassSet {
     public:
         // This will always construct the basic load store render pass (all attachments load and
         // store their data) so that there is at least one compatible VkRenderPass that can be used
         // with this set.
         CompatibleRenderPassSet(const GrVkGpu* gpu, const GrVkRenderTarget& target);
 
         bool isCompatible(const GrVkRenderTarget& target) const;
 
         GrVkRenderPass* getCompatibleRenderPass() const {
@@ skipping 34 matching lines @@
     // Array of available secondary command buffers
     SkSTArray<16, GrVkSecondaryCommandBuffer*> fAvailableSecondaryCommandBuffers;
 
     // 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;
+
+    GrVkDescriptorSetManager::Handle       fUniformDSHandle;
+
     // Current pool to allocate uniform descriptor sets from
-    const GrVkDescriptorPool* fUniformDescPool;
     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
     };
 };
 
 #endif