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

src/gpu/vk/GrVkProgram.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef GrVkProgram_DEFINED
 #define GrVkProgram_DEFINED
@@ skipping 29 matching lines @@
     void addUniformResources(GrVkCommandBuffer&);
 
     void freeGPUResources(const GrVkGpu* gpu);
 
     // This releases resources the only a given instance of a GrVkProgram needs to hold onto and do
     // don't need to survive across new uses of the program.
     void freeTempResources(const GrVkGpu* gpu);
 
     void abandonGPUResources();
 
+    // The key is composed of two parts:
+    // 1. uint32_t for total key length
+    // 2. Vulkan specific data
+    enum KeyOffsets {
+        // Part 1.
+        kLength_KeyOffset = 0,
+        // Part 2.
+        kData_KeyOffset = kLength_KeyOffset + sizeof(uint32_t),
+    };
+
+    static void BuildVkKey(const GrPipeline&, GrPrimitiveType primitiveType,
+                           SkTArray<unsigned char, true>* key);
+
+    struct PipelineDesc {
+        uint32_t                fChecksum;
+        GrVkProgramDesc         fProgramDesc;
+        SkTArray<uint8_t, true> fVkKey;

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

Any idea what the typical size is? Wonder if we should use a SkSTArray here.

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

Changed this to STArray

+
+        bool operator== (const PipelineDesc& that) const {
+            if (fChecksum != that.fChecksum || fProgramDesc != that.fProgramDesc) {
+                return false;
+            }
+            // We store the keyLength at the start of fVkKey. Thus we don't have to worry about
+            // different length keys since we will fail on the comparison immediately. Therefore we
+            // just use this PipelineDesc to get the length to iterate over.
+            int keyLength = fVkKey.count();
+            SkASSERT(SkIsAlign4(keyLength));
+            int l = keyLength >> 2;
+            const uint32_t* aKey = reinterpret_cast<const uint32_t*>(fVkKey.begin());
+            const uint32_t* bKey = reinterpret_cast<const uint32_t*>(that.fVkKey.begin());;
+            for (int i = 0; i < l; ++i) {
+                if (aKey[i] != bKey[i]) {
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        static bool Less(const PipelineDesc& a, const PipelineDesc& b) {

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

Is there a reason you didn't use operator<?

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

Mostly just following the template from GL. SkTSearch does need to take a Less
functor, but we do wrap that in the PipelineDescLess struct. Using the Less
function just kind of follows along with the use of a functor, but really I we
could use the operator instead.

+            if (a.fChecksum != b.fChecksum) {
+                return a.fChecksum < b.fChecksum ? true : false;
+            }
+            bool progDescLess = GrProgramDesc::Less(a.fProgramDesc, b.fProgramDesc);
+            if (progDescLess || a.fProgramDesc != b.fProgramDesc) {
+                return progDescLess;
+            }
+
+            int keyLength = a.fVkKey.count();
+            SkASSERT(SkIsAlign4(keyLength));
+            int l = keyLength >> 2;
+            const uint32_t* aKey = reinterpret_cast<const uint32_t*>(a.fVkKey.begin());
+            const uint32_t* bKey = reinterpret_cast<const uint32_t*>(b.fVkKey.begin());;
+            for (int i = 0; i < l; ++i) {
+                if (aKey[i] != bKey[i]) {
+                    return aKey[i] < bKey[i] ? true : false;
+                }
+            }
+            return false;
+        }
+
+    };
+
+    const PipelineDesc& getDesc() { return fPipelineDesc; }
+
 private:
     typedef GrVkProgramDataManager::UniformInfoArray UniformInfoArray;
     typedef GrGLSLProgramDataManager::UniformHandle UniformHandle;
 
     GrVkProgram(GrVkGpu* gpu,
+                const GrVkProgram::PipelineDesc&,
                 GrVkPipeline* pipeline,
                 VkPipelineLayout layout,
                 VkDescriptorSetLayout dsLayout[2],
                 const BuiltinUniformHandles& builtinUniformHandles,
                 const UniformInfoArray& uniforms,
                 uint32_t vertexUniformSize,
                 uint32_t fragmentUniformSize,
                 uint32_t numSamplers,
                 GrGLSLPrimitiveProcessor* geometryProcessor,
                 GrGLSLXferProcessor* xferProcessor,
@@ skipping 105 matching lines @@
 
     // Tracks the current render target uniforms stored in the vertex buffer.
     RenderTargetState fRenderTargetState;
     BuiltinUniformHandles fBuiltinUniformHandles;
 
     // Processors in the program
     SkAutoTDelete<GrGLSLPrimitiveProcessor> fGeometryProcessor;
     SkAutoTDelete<GrGLSLXferProcessor> fXferProcessor;
     GrGLSLFragProcs fFragmentProcessors;
 
+    PipelineDesc   fPipelineDesc;
+
     GrVkProgramDataManager fProgramDataManager;
 
     DescriptorPoolManager  fSamplerPoolManager;
     DescriptorPoolManager  fUniformPoolManager;
 
-#ifdef SK_DEBUG
     int fNumSamplers;
-#endif
 
     friend class GrVkProgramBuilder;
 };
 
 #endif