Change VkPipelineStateCahce to use Hash and LRU LList.

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 "GrVkPipelineState.h"
 #include "GrVkResource.h"
 #include "GrVkUtil.h"
 #include "SkTArray.h"
 #include "SkTDynamicHash.h"
+#include "SkTHash.h"
+#include "SkTInternalLList.h"
 
 #include "vulkan/vulkan.h"
 
 class GrPipeline;
 class GrPrimitiveProcessor;
 class GrTextureParams;
 class GrVkCommandBuffer;
 class GrVkGpu;
 class GrVkPipeline;
 class GrVkRenderPass;
@@ skipping 28 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&);
 
-    GrVkPipelineState* findOrCreateCompatiblePipelineState(const GrPipeline&,
-                                                           const GrPrimitiveProcessor&,
-                                                           GrPrimitiveType,
-                                                           const GrVkRenderPass& renderPass);
+    sk_sp<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
     // 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:
+
+#ifdef SK_DEVELOPER
+#define GR_PIPELINE_STATE_CACHE_STATS
+#endif
+
     class PipelineStateCache : public ::SkNoncopyable {
     public:
         PipelineStateCache(GrVkGpu* gpu);
         ~PipelineStateCache();
 
         void abandon();
         void release();
-        GrVkPipelineState* refPipelineState(const GrPipeline&,
-                                            const GrPrimitiveProcessor&,
-                                            GrPrimitiveType,
-                                            const GrVkRenderPass& renderPass);
+        sk_sp<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;
+        int                         fCount;
+        SkTHashTable<Entry*, const GrVkPipelineState::Desc&, Entry> fHashTable;
+        SkTInternalLList<Entry> fLRUList;
 
-        // 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];
+        GrVkGpu*                    fGpu;
 
-        int                         fCount;
-        unsigned int                fCurrLRUStamp;
-        GrVkGpu*                    fGpu;
-#ifdef PIPELINE_STATE_CACHE_STATS
+#ifdef GR_PIPELINE_STATE_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;
 
     // 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
     // GrVkPipelineStates
     SkTDynamicHash<GrVkSampler, uint8_t> fSamplers;
 
     // Cache of GrVkPipelineStates
     PipelineStateCache* fPipelineStateCache;
 };
 
 #endif