Add resource tracking output and command buffer recycling

src/gpu/vk/GrVkCommandBuffer.cpp

 /*
 * Copyright 2015 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
 #include "GrVkCommandBuffer.h"
 
 #include "GrVkFramebuffer.h"
@@ skipping 34 matching lines @@
 
     this->onFreeGPUData(gpu);
 }
 
 void GrVkCommandBuffer::abandonSubResources() const {
     for (int i = 0; i < fTrackedResources.count(); ++i) {
         fTrackedResources[i]->unrefAndAbandon();
     }
 }
 
+void GrVkCommandBuffer::reset(GrVkGpu* gpu) {
+    SkASSERT(!fIsActive);
+    for (int i = 0; i < fTrackedResources.count(); ++i) {
+        fTrackedResources[i]->unref(gpu);
+    }
+    fTrackedResources.reset();
+
+    this->invalidateState();
+
+    // we will retain resources for later use
+    VkCommandBufferResetFlags flags = 0;
+    GR_VK_CALL(gpu->vkInterface(), ResetCommandBuffer(fCmdBuffer, flags));
+
+    this->onReset(gpu);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // CommandBuffer commands
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrVkCommandBuffer::pipelineBarrier(const GrVkGpu* gpu,
                                         VkPipelineStageFlags srcStageMask,
                                         VkPipelineStageFlags dstStageMask,
                                         bool byRegion,
                                         BarrierType barrierType,
                                         void* barrier) const {
@@ skipping 248 matching lines @@
 }
 
 void GrVkPrimaryCommandBuffer::endRenderPass(const GrVkGpu* gpu) {
     SkASSERT(fIsActive);
     SkASSERT(fActiveRenderPass);
     GR_VK_CALL(gpu->vkInterface(), CmdEndRenderPass(fCmdBuffer));
     fActiveRenderPass = nullptr;
 }
 
 void GrVkPrimaryCommandBuffer::executeCommands(const GrVkGpu* gpu,
-                                               const GrVkSecondaryCommandBuffer* buffer) {
+                                               GrVkSecondaryCommandBuffer* buffer) {
     SkASSERT(fIsActive);
     SkASSERT(fActiveRenderPass);
     SkASSERT(fActiveRenderPass->isCompatible(*buffer->fActiveRenderPass));
 
     GR_VK_CALL(gpu->vkInterface(), CmdExecuteCommands(fCmdBuffer, 1, &buffer->fCmdBuffer));
-    this->addResource(buffer);
+    buffer->ref();
+    fSecondaryCommandBuffers.push_back(buffer);
     // When executing a secondary command buffer all state (besides render pass state) becomes
     // invalidated and must be reset. This includes bound buffers, pipelines, dynamic state, etc.
     this->invalidateState();
 }
 
 void GrVkPrimaryCommandBuffer::submitToQueue(const GrVkGpu* gpu,
                                              VkQueue queue,
                                              GrVkGpu::SyncQueue sync) {
     SkASSERT(!fIsActive);
 
     VkResult err;
-    VkFenceCreateInfo fenceInfo;
-    memset(&fenceInfo, 0, sizeof(VkFenceCreateInfo));
-    fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
-    err = GR_VK_CALL(gpu->vkInterface(), CreateFence(gpu->device(), &fenceInfo, nullptr,
-                                                     &fSubmitFence));
-    SkASSERT(!err);
+    if (VK_NULL_HANDLE == fSubmitFence) {
+        VkFenceCreateInfo fenceInfo;
+        memset(&fenceInfo, 0, sizeof(VkFenceCreateInfo));
+        fenceInfo.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
+        err = GR_VK_CALL(gpu->vkInterface(), CreateFence(gpu->device(), &fenceInfo, nullptr,
+                                                         &fSubmitFence));
+        SkASSERT(!err);
+    } else {
+        GR_VK_CALL(gpu->vkInterface(), ResetFences(gpu->device(), 1, &fSubmitFence));
+    }
 
     VkSubmitInfo submitInfo;
     memset(&submitInfo, 0, sizeof(VkSubmitInfo));
     submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
     submitInfo.pNext = nullptr;
     submitInfo.waitSemaphoreCount = 0;
     submitInfo.pWaitSemaphores = nullptr;
     submitInfo.pWaitDstStageMask = 0;
     submitInfo.commandBufferCount = 1;
     submitInfo.pCommandBuffers = &fCmdBuffer;
@@ skipping 31 matching lines @@
 
         default:
             SkDebugf("Error getting fence status: %d\n", err);
             SkFAIL("failing");
             break;
     }
 
     return false;
 }
 
+void GrVkPrimaryCommandBuffer::onReset(GrVkGpu* gpu) {
+    for (int i = 0; i < fSecondaryCommandBuffers.count(); ++i) {
+        gpu->resourceProvider().recycleSecondaryCommandBuffer(fSecondaryCommandBuffers[i]);
+    }
+    fSecondaryCommandBuffers.reset();
+}
+
 void GrVkPrimaryCommandBuffer::copyImage(const GrVkGpu* gpu,
                                          GrVkImage* srcImage,
                                          VkImageLayout srcLayout,
                                          GrVkImage* dstImage,
                                          VkImageLayout dstLayout,
                                          uint32_t copyRegionCount,
                                          const VkImageCopy* copyRegions) {
     SkASSERT(fIsActive);
     SkASSERT(!fActiveRenderPass);
     this->addResource(srcImage->resource());
@@ skipping 123 matching lines @@
     // Destroy the fence, if any
     if (VK_NULL_HANDLE != fSubmitFence) {
         GR_VK_CALL(gpu->vkInterface(), DestroyFence(gpu->device(), fSubmitFence, nullptr));
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // SecondaryCommandBuffer
 ////////////////////////////////////////////////////////////////////////////////
 
-GrVkSecondaryCommandBuffer* GrVkSecondaryCommandBuffer::Create(
-                                                       const GrVkGpu* gpu,
-                                                       VkCommandPool cmdPool,
-                                                       const GrVkRenderPass* compatibleRenderPass) {
+GrVkSecondaryCommandBuffer* GrVkSecondaryCommandBuffer::Create(const GrVkGpu* gpu,
+                                                               VkCommandPool cmdPool) {
     const VkCommandBufferAllocateInfo cmdInfo = {
         VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,   // sType
         NULL,                                             // pNext
         cmdPool,                                          // commandPool
         VK_COMMAND_BUFFER_LEVEL_SECONDARY,                // level
         1                                                 // bufferCount
     };
 
     VkCommandBuffer cmdBuffer;
     VkResult err = GR_VK_CALL(gpu->vkInterface(), AllocateCommandBuffers(gpu->device(),
                                                                          &cmdInfo,
                                                                          &cmdBuffer));
     if (err) {
         return nullptr;
     }
-    return new GrVkSecondaryCommandBuffer(cmdBuffer, compatibleRenderPass);
+    return new GrVkSecondaryCommandBuffer(cmdBuffer);
 }
 
 
-void GrVkSecondaryCommandBuffer::begin(const GrVkGpu* gpu, const GrVkFramebuffer* framebuffer) {
+void GrVkSecondaryCommandBuffer::begin(const GrVkGpu* gpu, const GrVkFramebuffer* framebuffer,
+                                       const GrVkRenderPass* compatibleRenderPass) {
     SkASSERT(!fIsActive);
-    SkASSERT(fActiveRenderPass);
+    SkASSERT(compatibleRenderPass);
+    fActiveRenderPass = compatibleRenderPass;
 
     VkCommandBufferInheritanceInfo inheritanceInfo;
     memset(&inheritanceInfo, 0, sizeof(VkCommandBufferInheritanceInfo));
     inheritanceInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
     inheritanceInfo.pNext = nullptr;
     inheritanceInfo.renderPass = fActiveRenderPass->vkRenderPass();
     inheritanceInfo.subpass = 0; // Currently only using 1 subpass for each render pass
     inheritanceInfo.framebuffer = framebuffer ? framebuffer->framebuffer() : VK_NULL_HANDLE;
     inheritanceInfo.occlusionQueryEnable = false;
     inheritanceInfo.queryFlags = 0;
@@ skipping 12 matching lines @@
     fIsActive = true;
 }
 
 void GrVkSecondaryCommandBuffer::end(const GrVkGpu* gpu) {
     SkASSERT(fIsActive);
     GR_VK_CALL_ERRCHECK(gpu->vkInterface(), EndCommandBuffer(fCmdBuffer));
     this->invalidateState();
     fIsActive = false;
 }