Add resource tracking output and command buffer recycling

src/gpu/vk/GrVkCommandBuffer.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 GrVkCommandBuffer_DEFINED
 #define GrVkCommandBuffer_DEFINED
 
@@ skipping 99 matching lines @@
               uint32_t firstVertex,
               uint32_t firstInstance) const;
 
     // Add ref-counted resource that will be tracked and released when this
     // command buffer finishes execution
     void addResource(const GrVkResource* resource) {
         resource->ref();
         fTrackedResources.push_back(resource);
     }
 
+    void reset(GrVkGpu* gpu);
+
 protected:
         GrVkCommandBuffer(VkCommandBuffer cmdBuffer, const GrVkRenderPass* rp = VK_NULL_HANDLE)
             : fTrackedResources(kInitialTrackedResourcesCount)
             , fIsActive(false)
             , fActiveRenderPass(rp)
             , fCmdBuffer(cmdBuffer)
             , fBoundVertexBufferIsValid(false)
             , fBoundIndexBufferIsValid(false) {
             this->invalidateState();
         }
@@ skipping 10 matching lines @@
 
         VkCommandBuffer           fCmdBuffer;
 
 private:
     static const int kInitialTrackedResourcesCount = 32;
 
     void freeGPUData(const GrVkGpu* gpu) const override;
     virtual void onFreeGPUData(const GrVkGpu* gpu) const = 0;
     void abandonSubResources() const override;
 
+    virtual void onReset(GrVkGpu* gpu) {}
+
     VkBuffer                                fBoundVertexBuffer;
     bool                                    fBoundVertexBufferIsValid;
 
     VkBuffer                                fBoundIndexBuffer;
     bool                                    fBoundIndexBufferIsValid;
 
     // Cached values used for dynamic state updates
     VkViewport fCachedViewport;
     VkRect2D   fCachedScissor;
     float      fCachedBlendConstant[4];
@@ skipping 18 matching lines @@
                          const VkClearValue* clearValues,
                          const GrVkRenderTarget& target,
                          const SkIRect& bounds,
                          bool forSecondaryCB);
     void endRenderPass(const GrVkGpu* gpu);
 
     // Submits the SecondaryCommandBuffer into this command buffer. It is required that we are
     // currently inside a render pass that is compatible with the one used to create the
     // SecondaryCommandBuffer.
     void executeCommands(const GrVkGpu* gpu,
-                         const GrVkSecondaryCommandBuffer* secondaryBuffer);
+                         GrVkSecondaryCommandBuffer* secondaryBuffer);
 
     // Commands that only work outside of a render pass
     void clearColorImage(const GrVkGpu* gpu,
                          GrVkImage* image,
                          const VkClearColorValue* color,
                          uint32_t subRangeCount,
                          const VkImageSubresourceRange* subRanges);
 
     void clearDepthStencilImage(const GrVkGpu* gpu,
                                 GrVkImage* image,
@@ skipping 54 matching lines @@
 
     void updateBuffer(GrVkGpu* gpu,
                       GrVkBuffer* dstBuffer,
                       VkDeviceSize dstOffset,
                       VkDeviceSize dataSize,
                       const void* data);
 
     void submitToQueue(const GrVkGpu* gpu, VkQueue queue, GrVkGpu::SyncQueue sync);
     bool finished(const GrVkGpu* gpu) const;
 
+#ifdef SK_TRACE_VK_RESOURCES
+    void dumpInfo() const override {
+        SkDebugf("GrVkPrimaryCommandBuffer: %d (%d refs)\n", fCmdBuffer, this->getRefCnt());
+    }
+#endif
+
 private:
     explicit GrVkPrimaryCommandBuffer(VkCommandBuffer cmdBuffer)
         : INHERITED(cmdBuffer)
         , fSubmitFence(VK_NULL_HANDLE) {}
 
     void onFreeGPUData(const GrVkGpu* gpu) const override;
 
-    VkFence                   fSubmitFence;
+    void onReset(GrVkGpu* gpu) override;
+
+    SkTArray<GrVkSecondaryCommandBuffer*, true> fSecondaryCommandBuffers;
+    VkFence                                     fSubmitFence;
 
     typedef GrVkCommandBuffer INHERITED;
 };
 
 class GrVkSecondaryCommandBuffer : public GrVkCommandBuffer {
 public:
-    static GrVkSecondaryCommandBuffer* Create(const GrVkGpu* gpu, VkCommandPool cmdPool, 
-                                              const GrVkRenderPass* compatibleRenderPass);
+    static GrVkSecondaryCommandBuffer* Create(const GrVkGpu* gpu, VkCommandPool cmdPool);
 
-    void begin(const GrVkGpu* gpu, const GrVkFramebuffer* framebuffer);
+    void begin(const GrVkGpu* gpu, const GrVkFramebuffer* framebuffer,
+               const GrVkRenderPass* compatibleRenderPass);
     void end(const GrVkGpu* gpu);
 
+#ifdef SK_TRACE_VK_RESOURCES
+    void dumpInfo() const override {
+        SkDebugf("GrVkSecondaryCommandBuffer: %d (%d refs)\n", fCmdBuffer, this->getRefCnt());
+    }
+#endif
+
 private:
-    explicit GrVkSecondaryCommandBuffer(VkCommandBuffer cmdBuffer,
-                                        const GrVkRenderPass* compatibleRenderPass)
-        : INHERITED(cmdBuffer, compatibleRenderPass) {
+    explicit GrVkSecondaryCommandBuffer(VkCommandBuffer cmdBuffer)
+        : INHERITED(cmdBuffer) {
     }
 
     void onFreeGPUData(const GrVkGpu* gpu) const override {}
 
     friend class GrVkPrimaryCommandBuffer;
 
     typedef GrVkCommandBuffer INHERITED;
 };
 
 #endif