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

src/gpu/vk/GrVkResourceProvider.h

Index: src/gpu/vk/GrVkResourceProvider.h
diff --git a/src/gpu/vk/GrVkResourceProvider.h b/src/gpu/vk/GrVkResourceProvider.h
index 66a2556a9398ba7e9cfa8e8f1a48875072406456..5146763d6e993884dcf8b0e17f41d8c6b53d77a5 100644
--- a/src/gpu/vk/GrVkResourceProvider.h
+++ b/src/gpu/vk/GrVkResourceProvider.h
@@ -8,7 +8,9 @@
 #ifndef GrVkResourceProvider_DEFINED
 #define GrVkResourceProvider_DEFINED
 
+#include "GrGpu.h"
 #include "GrVkDescriptorPool.h"
+#include "GrVkPipelineState.h"
 #include "GrVkResource.h"
 #include "GrVkUtil.h"
 #include "SkTArray.h"
@@ -61,6 +63,11 @@ public:
     // The refcount is incremented and a pointer returned.
     GrVkSampler* findOrCreateCompatibleSampler(const GrTextureParams&);
 
+    GrVkPipelineState* findOrCreateCompatiblePipelineState(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
@@ -73,6 +80,52 @@ public:
     void abandonResources();
 
 private:
+    class PipelineStateCache : public ::SkNoncopyable {
+    public:
+        PipelineStateCache(GrVkGpu* gpu);
+        ~PipelineStateCache();
+
+        void abandon();
+        void release();
+        GrVkPipelineState* refPipelineState(const GrPipeline&,
+                                            const GrPrimitiveProcessor&,
+                                            GrPrimitiveType,
+                                            const GrVkRenderPass& renderPass);
+
+    private:
+        enum {
+            // We may actually have kMaxEntries+1 PipelineStates in context because we create a new
+            // PipelineState 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 GrVkPipelineState::Desc& desc) const;
+
+        // sorted array of all the entries
+        Entry*                      fEntries[kMaxEntries];
+        // hash table based on lowest kHashBits bits of the pipeline state key. Used to avoid binary
+        // searching fEntries.
+        Entry*                      fHashTable[1 << kHashBits];
+
+        int                         fCount;
+        unsigned int                fCurrLRUStamp;
+        GrVkGpu*                    fGpu;
+#ifdef PIPELINE_STATE__CACHE_STATS
+        int                         fTotalRequests;
+        int                         fCacheMisses;
+        int                         fHashMisses; // cache hit but hash table missed
+#endif
+    };
+
     GrVkGpu* fGpu;
 
     // Central cache for creating pipelines
@@ -80,14 +133,17 @@ private:
 
     // 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;

[bsalomon, 2016/03/23 15:04:37]

Can you either leave all the members staggered or align them all?

[egdaniel, 2016/03/23 19:12:07]

Done.

 
     // 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
+    // GrVkPipelineStates
     SkTDynamicHash<GrVkSampler, uint8_t> fSamplers;
+
+    // Cache of GrVkPipelineStates
+    PipelineStateCache*                  fPipelineStateCache;
 };
 
 #endif