Recycle small uniform buffers.

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 "GrVkRenderTarget.h"
 #include "GrVkSampler.h"
+#include "GrVkUniformBuffer.h"
 #include "GrVkUtil.h"
 
 #ifdef SK_TRACE_VK_RESOURCES
 GrVkResource::Trace GrVkResource::fTrace;
 uint32_t GrVkResource::fKeyCounter = 0;
 #endif
 
 GrVkResourceProvider::GrVkResourceProvider(GrVkGpu* gpu)
     : fGpu(gpu)
     , fPipelineCache(VK_NULL_HANDLE)
@@ skipping 233 matching lines @@
         cmdBuffer = GrVkSecondaryCommandBuffer::Create(fGpu, fGpu->cmdPool());
     }
     return cmdBuffer;
 }
 
 void GrVkResourceProvider::recycleSecondaryCommandBuffer(GrVkSecondaryCommandBuffer* cb) {
     cb->reset(fGpu);
     fAvailableSecondaryCommandBuffers.push_back(cb);
 }
 
+const GrVkResource* GrVkResourceProvider::findOrCreateStandardUniformBufferResource() {
+    const GrVkResource* resource = nullptr;
+    int count = fAvailableUniformBufferResources.count();
+    if (count > 0) {
+        resource = fAvailableUniformBufferResources[count - 1];
+        fAvailableUniformBufferResources.removeShuffle(count - 1);
+    } else {
+        resource = GrVkUniformBuffer::CreateResource(fGpu, GrVkUniformBuffer::kStandardSize);
+    }
+    return resource;
+}
+
+void GrVkResourceProvider::recycleStandardUniformBufferResource(const GrVkResource* resource) {
+    resource->ref();
+    fAvailableUniformBufferResources.push_back(resource);
+}
+
 void GrVkResourceProvider::destroyResources() {
     // release our active command buffers
     for (int i = 0; i < fActiveCommandBuffers.count(); ++i) {
         SkASSERT(fActiveCommandBuffers[i]->finished(fGpu));
         SkASSERT(fActiveCommandBuffers[i]->unique());
         fActiveCommandBuffers[i]->reset(fGpu);
         fActiveCommandBuffers[i]->unref(fGpu);
     }
     fActiveCommandBuffers.reset();
     // release our available command buffers
@@ skipping 29 matching lines @@
     GR_VK_CALL(fGpu->vkInterface(), DestroyPipelineCache(fGpu->device(), fPipelineCache, nullptr));
     fPipelineCache = VK_NULL_HANDLE;
 
     if (fUniformDescLayout) {
         GR_VK_CALL(fGpu->vkInterface(), DestroyDescriptorSetLayout(fGpu->device(),
                                                                    fUniformDescLayout,
                                                                    nullptr));
         fUniformDescLayout = VK_NULL_HANDLE;
     }
     fUniformDescPool->unref(fGpu);
+
+    // release our uniform buffers

[egdaniel, 2016/07/19 20:48:37]

do you need an abandon form of this?

+    for (int i = 0; i < fAvailableUniformBufferResources.count(); ++i) {
+        SkASSERT(fAvailableUniformBufferResources[i]->unique());
+        fAvailableUniformBufferResources[i]->unref(fGpu);
+    }
+    fAvailableUniformBufferResources.reset();
 }
 
 void GrVkResourceProvider::abandonResources() {
     // release our active command buffers
     for (int i = 0; i < fActiveCommandBuffers.count(); ++i) {
         SkASSERT(fActiveCommandBuffers[i]->finished(fGpu));
         SkASSERT(fActiveCommandBuffers[i]->unique());
         fActiveCommandBuffers[i]->unrefAndAbandon();
     }
     fActiveCommandBuffers.reset();
@@ skipping 79 matching lines @@
 }
 
 void GrVkResourceProvider::CompatibleRenderPassSet::abandonResources() {
     for (int i = 0; i < fRenderPasses.count(); ++i) {
         if (fRenderPasses[i]) {
             fRenderPasses[i]->unrefAndAbandon();
             fRenderPasses[i] = nullptr;
         }
     }
 }