Add a cache of GrVkSamplers in GrVkResourceProvider.

src/gpu/vk/GrVkResourceProvider.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 "GrVkResourceProvider.h"
 
+#include "GrTextureParams.h"
 #include "GrVkCommandBuffer.h"
 #include "GrVkPipeline.h"
 #include "GrVkRenderPass.h"
+#include "GrVkSampler.h"
 #include "GrVkUtil.h"
 
 #ifdef SK_TRACE_VK_RESOURCES
 SkTDynamicHash<GrVkResource, uint32_t> GrVkResource::fTrace;
 SkRandom GrVkResource::fRandom;
 #endif
 
 GrVkResourceProvider::GrVkResourceProvider(GrVkGpu* gpu) : fGpu(gpu)
                                                          , fPipelineCache(VK_NULL_HANDLE) {
 }
@@ skipping 51 matching lines @@
     fSimpleRenderPasses.push_back(renderPass);
     renderPass->ref();
     return renderPass;
 }
 
 GrVkDescriptorPool* GrVkResourceProvider::findOrCreateCompatibleDescriptorPool(
                                        const GrVkDescriptorPool::DescriptorTypeCounts& typeCounts) {
     return new GrVkDescriptorPool(fGpu, typeCounts);
 }
 
+GrVkSampler* GrVkResourceProvider::findOrCreateCompatibleSampler(const GrTextureParams& params) {
+    GrVkSampler* sampler = fSamplers.find(GrVkSampler::GenerateKey(params));
+    if (!sampler) {
+        sampler = GrVkSampler::Create(fGpu, params);
+        fSamplers.add(sampler);
+    }
+    SkASSERT(sampler);
+    sampler->ref();
+    return sampler;
+}
+
 GrVkCommandBuffer* GrVkResourceProvider::createCommandBuffer() {
     GrVkCommandBuffer* cmdBuffer = GrVkCommandBuffer::Create(fGpu, fGpu->cmdPool());
     fActiveCommandBuffers.push_back(cmdBuffer);
     cmdBuffer->ref();
     return cmdBuffer;
 }
 
 void GrVkResourceProvider::checkCommandBuffers() {
     for (int i = fActiveCommandBuffers.count()-1; i >= 0; --i) {
         if (fActiveCommandBuffers[i]->finished(fGpu)) {
@@ skipping 11 matching lines @@
         fActiveCommandBuffers[i]->unref(fGpu);
     }
     fActiveCommandBuffers.reset();
 
     // loop over all render passes to make sure we destroy all the internal VkRenderPasses
     for (int i = 0; i < fSimpleRenderPasses.count(); ++i) {
         fSimpleRenderPasses[i]->unref(fGpu);
     }
     fSimpleRenderPasses.reset();
 
+    // Iterate through all store GrVkSamplers and unref them before resetting the hash.
+    SkTDynamicHash<GrVkSampler, uint8_t>::Iter iter(&fSamplers);
+    for (; !iter.done(); ++iter) {
+        (*iter).unref(fGpu);
+    }
+    fSamplers.reset();
+
 #ifdef SK_TRACE_VK_RESOURCES
     SkASSERT(0 == GrVkResource::fTrace.count());
 #endif
 
     GR_VK_CALL(fGpu->vkInterface(), DestroyPipelineCache(fGpu->device(), fPipelineCache, nullptr));
     fPipelineCache = VK_NULL_HANDLE;
 }
 
 void GrVkResourceProvider::abandonResources() {
     // release our current command buffers
     for (int i = 0; i < fActiveCommandBuffers.count(); ++i) {
         SkASSERT(fActiveCommandBuffers[i]->finished(fGpu));
         fActiveCommandBuffers[i]->unrefAndAbandon();
     }
     fActiveCommandBuffers.reset();
 
     for (int i = 0; i < fSimpleRenderPasses.count(); ++i) {
         fSimpleRenderPasses[i]->unrefAndAbandon();
     }
     fSimpleRenderPasses.reset();
 
+    // Iterate through all store GrVkSamplers and unrefAndAbandon them before resetting the hash.
+    SkTDynamicHash<GrVkSampler, uint8_t>::Iter iter(&fSamplers);
+    for (; !iter.done(); ++iter) {
+        (*iter).unrefAndAbandon();
+    }
+    fSamplers.reset();
+
 #ifdef SK_TRACE_VK_RESOURCES
     SkASSERT(0 == GrVkResource::fTrace.count());
 #endif
     fPipelineCache = VK_NULL_HANDLE;
 }