Set up cache in vulkan to reuse GrVkPrograms (aka VkPipelines)

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 "GrVkDescriptorPool.h"
+#include "GrVkProgram.h"
 #include "GrVkResource.h"
 #include "GrVkUtil.h"
 #include "SkTArray.h"
 #include "SkTDynamicHash.h"
 
 #include "vulkan/vulkan.h"
 
 class GrPipeline;
 class GrPrimitiveProcessor;
 class GrTextureParams;
@@ skipping 32 matching lines @@
     // TODO: Currently this will just create a descriptor pool without holding onto a ref itself
     //       so we currently do not reuse them. Rquires knowing if another draw is currently using
     //       the GrVkDescriptorPool, the ability to reset pools, and the ability to purge pools out
     //       of our cache of GrVkDescriptorPools.
     GrVkDescriptorPool* findOrCreateCompatibleDescriptorPool(VkDescriptorType type, uint32_t count);
 
     // Finds or creates a compatible GrVkSampler based on the GrTextureParams.
     // The refcount is incremented and a pointer returned.
     GrVkSampler* findOrCreateCompatibleSampler(const GrTextureParams&);
 
+    GrVkProgram* findOrCreateCompatibleProgram(const GrPipeline&,
+                                               const GrPrimitiveProcessor&,
+                                               GrPrimitiveType,
+                                               const GrVkRenderPass& renderPass);
+
     // 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();
 
 private:
+    class ProgramCache : public ::SkNoncopyable {
+    public:
+ //       typedef GrGpu::DrawArgs DrawArgs;

[jvanverth1, 2016/03/21 21:16:16]

Still need this?

[egdaniel, 2016/03/22 20:06:14]

deleted

+
+        ProgramCache(GrVkGpu* gpu);
+        ~ProgramCache();
+
+        void abandon();
+        void release();
+        GrVkProgram* refProgram(const GrPipeline&,
+                                const GrPrimitiveProcessor&,
+                                GrPrimitiveType,
+                                const GrVkRenderPass& renderPass);
+
+    private:
+        enum {
+            // We may actually have kMaxEntries+1 shaders in the GL context because we create a new

[jvanverth1, 2016/03/21 21:16:16]

GL? And are these values good for Vulkan?

[egdaniel, 2016/03/21 22:23:52]

When I previously looked at the cache stats we were getting good hit rate with
these values. However, I can play around with them to see if anything improves.
Was there any actual reasoning behind these numbers in GL besides a guesstimate
of what would be good?

[bsalomon, 2016/03/22 14:00:33]

At various times in the past this was tuned to improve hit rates, but not
anytime recently.

[egdaniel, 2016/03/22 20:06:14]

Fixed comment. For now my rough testing shows decent values for this, but I will
punt on tuning this directly for this CL and do so in a follow on pass

+            // shader before evicting from the cache.
+            kMaxEntries = 128,
+            kHashBits = 6,
+        };
+
+        struct Entry;
+
+        struct PipelineDescLess;
+
+        void reset();
+
+        // binary search for entry matching desc. returns index into fEntries that matches desc or ~
+        // of the index of where it should be inserted.
+        int search(const GrVkProgram::PipelineDesc& desc) const;
+
+        // sorted array of all the entries
+        Entry*                      fEntries[kMaxEntries];
+        // hash table based on lowest kHashBits bits of the program key. Used to avoid binary
+        // searching fEntries.
+        Entry*                      fHashTable[1 << kHashBits];
+
+        int                         fCount;
+        unsigned int                fCurrLRUStamp;
+        GrVkGpu*                    fGpu;
+#ifdef PROGRAM_CACHE_STATS
+        int                         fTotalRequests;
+        int                         fCacheMisses;
+        int                         fHashMisses; // cache hit but hash table missed
+#endif
+    };
+
     GrVkGpu* fGpu;
 
     // Central cache for creating pipelines
     VkPipelineCache fPipelineCache;
 
     // Array of RenderPasses that only have a single color attachment, optional stencil attachment,
     // optional resolve attachment, and only one subpass
-    SkSTArray<4, GrVkRenderPass*> fSimpleRenderPasses;
+    SkSTArray<4, GrVkRenderPass*>    fSimpleRenderPasses;
 
     // Array of CommandBuffers that are currently in flight
     SkSTArray<4, GrVkCommandBuffer*> fActiveCommandBuffers;
 
     // Stores GrVkSampler objects that we've already created so we can reuse them across multiple
     // programs
     SkTDynamicHash<GrVkSampler, uint8_t> fSamplers;
+
+    // Cache of GrVkPrograms
+    ProgramCache*                    fProgramCache;
 };
 
 #endif