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

src/gpu/vk/GrVkProgram.cpp

 /*
 * Copyright 2016 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #include "GrVkProgram.h"
 
 #include "GrPipeline.h"
 #include "GrVkCommandBuffer.h"
 #include "GrVkDescriptorPool.h"
 #include "GrVkGpu.h"
 #include "GrVkImageView.h"
 #include "GrVkMemory.h"
 #include "GrVkPipeline.h"
+#include "GrVkRenderTarget.h"
 #include "GrVkSampler.h"
 #include "GrVkTexture.h"
 #include "GrVkUniformBuffer.h"
 #include "glsl/GrGLSLFragmentProcessor.h"
 #include "glsl/GrGLSLGeometryProcessor.h"
 #include "glsl/GrGLSLXferProcessor.h"
 
 GrVkProgram::GrVkProgram(GrVkGpu* gpu,
+                         const GrVkProgram::PipelineDesc& desc,
                          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,
                          const GrGLSLFragProcs& fragmentProcessors)
     : fPipeline(pipeline)
     , fPipelineLayout(layout)
     , fBuiltinUniformHandles(builtinUniformHandles)
     , fGeometryProcessor(geometryProcessor)
     , fXferProcessor(xferProcessor)
     , fFragmentProcessors(fragmentProcessors)
+    , fPipelineDesc(desc)
     , fProgramDataManager(uniforms, vertexUniformSize, fragmentUniformSize)
     , fSamplerPoolManager(dsLayout[GrVkUniformHandler::kSamplerDescSet],
                           VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, numSamplers, gpu)
     , fUniformPoolManager(dsLayout[GrVkUniformHandler::kUniformBufferDescSet],
                           VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 2, gpu) {
     fSamplers.setReserve(numSamplers);
     fTextureViews.setReserve(numSamplers);
     fTextures.setReserve(numSamplers);
 
     fDescriptorSets[0] = VK_NULL_HANDLE;
@@ skipping 166 matching lines @@
         descriptorWrites[0].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
         descriptorWrites[0].pNext = nullptr;
         descriptorWrites[0].dstSet = fDescriptorSets[1];
         descriptorWrites[0].dstBinding = GrVkUniformHandler::kVertexBinding;
         descriptorWrites[0].dstArrayElement = 0;
         descriptorWrites[0].descriptorCount = 1;
         descriptorWrites[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         descriptorWrites[0].pImageInfo = nullptr;
         descriptorWrites[0].pBufferInfo = &vertBufferInfo;
         descriptorWrites[0].pTexelBufferView = nullptr;
+
+        fVertexUniformBuffer->addMemoryBarrier(gpu,
+                                               VK_ACCESS_HOST_WRITE_BIT,
+                                               VK_ACCESS_UNIFORM_READ_BIT,
+                                               VK_PIPELINE_STAGE_HOST_BIT,
+                                               VK_PIPELINE_STAGE_VERTEX_SHADER_BIT,
+                                               false);
     }
 
     VkDescriptorBufferInfo fragBufferInfo;
     // Fragment Uniform Buffer
     if (fFragmentUniformBuffer.get()) {
         if (0 == uniformBindingUpdateCount) {
             firstUniformWrite = 1;
         }
         ++uniformBindingUpdateCount;
         memset(&fragBufferInfo, 0, sizeof(VkDescriptorBufferInfo));
         fragBufferInfo.buffer = fFragmentUniformBuffer->buffer();
         fragBufferInfo.offset = 0;
         fragBufferInfo.range = fFragmentUniformBuffer->size();
 
         descriptorWrites[1].sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
         descriptorWrites[1].pNext = nullptr;
         descriptorWrites[1].dstSet = fDescriptorSets[1];
         descriptorWrites[1].dstBinding = GrVkUniformHandler::kFragBinding;;
         descriptorWrites[1].dstArrayElement = 0;
         descriptorWrites[1].descriptorCount = 1;
         descriptorWrites[1].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
         descriptorWrites[1].pImageInfo = nullptr;
         descriptorWrites[1].pBufferInfo = &fragBufferInfo;
         descriptorWrites[1].pTexelBufferView = nullptr;
+
+        fFragmentUniformBuffer->addMemoryBarrier(gpu,
+                                                 VK_ACCESS_HOST_WRITE_BIT,
+                                                 VK_ACCESS_UNIFORM_READ_BIT,
+                                                 VK_PIPELINE_STAGE_HOST_BIT,
+                                                 VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT,
+                                                 false);
     }
 
     if (uniformBindingUpdateCount) {
         GR_VK_CALL(gpu->vkInterface(), UpdateDescriptorSets(gpu->device(),
                                                             uniformBindingUpdateCount,
                                                             &descriptorWrites[firstUniformWrite],
                                                             0, nullptr));
     }
 }
 
@@ skipping 142 matching lines @@
     }
     fCurrentDescriptorSet++;
 
     VkDescriptorSetAllocateInfo dsAllocateInfo;
     memset(&dsAllocateInfo, 0, sizeof(VkDescriptorSetAllocateInfo));
     dsAllocateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
     dsAllocateInfo.pNext = nullptr;
     dsAllocateInfo.descriptorPool = fPool->descPool();
     dsAllocateInfo.descriptorSetCount = 1;
     dsAllocateInfo.pSetLayouts = &fDescLayout;
-
     GR_VK_CALL_ERRCHECK(gpu->vkInterface(), AllocateDescriptorSets(gpu->device(),
                                                                    &dsAllocateInfo,
                                                                    ds));
 }
 
 void GrVkProgram::DescriptorPoolManager::freeGPUResources(const GrVkGpu* gpu) {
     if (fDescLayout) {
         GR_VK_CALL(gpu->vkInterface(), DestroyDescriptorSetLayout(gpu->device(), fDescLayout,
                                                                   nullptr));
         fDescLayout = VK_NULL_HANDLE;
     }
 
     if (fPool) {
         fPool->unref(gpu);
         fPool = nullptr;
     }
 }
 
 void GrVkProgram::DescriptorPoolManager::abandonGPUResources() {
     fDescLayout = VK_NULL_HANDLE;
     if (fPool) {
         fPool->unrefAndAbandon();
         fPool = nullptr;
     }
 }
+
+uint32_t get_blend_info_key(const GrPipeline& pipeline) {
+    GrXferProcessor::BlendInfo blendInfo;
+    pipeline.getXferProcessor().getBlendInfo(&blendInfo);
+
+    static const uint32_t kBlendWriteShift = 1;
+    static const uint32_t kBlendCoeffShift = 5;
+    GR_STATIC_ASSERT(kLast_GrBlendCoeff < (1 << kBlendCoeffShift));
+    GR_STATIC_ASSERT(kFirstAdvancedGrBlendEquation - 1 < 4);
+
+    uint32_t key = blendInfo.fWriteColor;
+    key |= (blendInfo.fSrcBlend << kBlendWriteShift);
+    key |= (blendInfo.fDstBlend << (kBlendWriteShift + kBlendCoeffShift));
+    key |= (blendInfo.fEquation << (kBlendWriteShift + 2 * kBlendCoeffShift));
+
+    return key;
+}
+
+void GrVkProgram::BuildVkKey(const GrPipeline& pipeline, GrPrimitiveType primitiveType,
+                             SkTArray<unsigned char, true>* key) {

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

uint8_t in the class and unsigned char here

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

Done.

+    // Save room for the key length and key header
+    key->reset();
+    key->push_back_n(kData_KeyOffset);
+
+    GrProcessorKeyBuilder b(key);
+
+    GrVkRenderTarget* vkRT = (GrVkRenderTarget*)pipeline.getRenderTarget();
+    vkRT->simpleRenderPass()->genKey(&b);
+
+    pipeline.getStencil().genKey(&b);
+
+    SkASSERT(sizeof(GrPipelineBuilder::DrawFace) <= sizeof(uint32_t));
+    b.add32(pipeline.getDrawFace());
+
+    b.add32(get_blend_info_key(pipeline));
+
+    b.add32(primitiveType);
+
+    // Set key length 
+    int keyLength = key->count();
+    SkASSERT(0 == (keyLength % 4));
+    *reinterpret_cast<uint32_t*>(key->begin()) = SkToU32(keyLength);
+}