Small perf optimizations preparing sampled images in vulkan

src/gpu/vk/GrVkGpuCommandBuffer.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 "GrVkGpuCommandBuffer.h"
 
 #include "GrFixedClip.h"
@@ skipping 85 matching lines @@
 
 GrGpu* GrVkGpuCommandBuffer::gpu() { return fGpu; }
 
 void GrVkGpuCommandBuffer::end() {
     fCommandBuffer->end(fGpu);
 }
 
 void GrVkGpuCommandBuffer::onSubmit(const SkIRect& bounds) {
     // Change layout of our render target so it can be used as the color attachment. Currently
     // we don't attach the resolve to the framebuffer so no need to change its layout.
-    GrVkImage* targetImage = fRenderTarget->msaaImage() ? fRenderTarget->msaaImage() 
+    GrVkImage* targetImage = fRenderTarget->msaaImage() ? fRenderTarget->msaaImage()
                                                         : fRenderTarget;
     targetImage->setImageLayout(fGpu,
                                 VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
                                 VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
                                 VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                                 false);
 
     // If we are using a stencil attachment we also need to update its layout
     if (GrStencilAttachment* stencil = fRenderTarget->renderTargetPriv().getStencilAttachment()) {
         GrVkStencilAttachment* vkStencil = (GrVkStencilAttachment*)stencil;
         vkStencil->setImageLayout(fGpu,
                                   VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
                                   VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT |
                                   VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT,
                                   VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
                                   false);
     }
 
-    for (int i = 0; i < fSampledImages.count(); ++i) {
-        fSampledImages[i]->setImageLayout(fGpu,
-                                          VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
-                                          VK_ACCESS_SHADER_READ_BIT,
-                                          VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
-                                          false);
-    }
-
     fGpu->submitSecondaryCommandBuffer(fCommandBuffer, fRenderPass, &fColorClearValue,
                                        fRenderTarget, bounds);
 }
 
 void GrVkGpuCommandBuffer::discard(GrRenderTarget* target) {
     if (fIsEmpty) {
         // We will change the render pass to do a clear load instead
         GrVkRenderPass::LoadStoreOps vkColorOps(VK_ATTACHMENT_LOAD_OP_DONT_CARE,
                                                 VK_ATTACHMENT_STORE_OP_STORE);
         GrVkRenderPass::LoadStoreOps vkStencilOps(VK_ATTACHMENT_LOAD_OP_DONT_CARE,
@@ skipping 191 matching lines @@
 
     pipelineState->setData(fGpu, primProc, pipeline);
 
     pipelineState->bind(fGpu, fCommandBuffer);
 
     GrVkPipeline::SetDynamicState(fGpu, fCommandBuffer, pipeline);
 
     return pipelineState;
 }
 
-static void append_sampled_images(const GrProcessor& processor,
-                                  GrVkGpu* gpu,
-                                  SkTArray<GrVkImage*>* sampledImages) {
-    if (int numTextures = processor.numTextures()) {
-        GrVkImage** images = sampledImages->push_back_n(numTextures);
-        int i = 0;
-        do {
-            const GrTextureAccess& texAccess = processor.textureAccess(i);
-            GrVkTexture* vkTexture = static_cast<GrVkTexture*>(processor.texture(i));
-            SkASSERT(vkTexture);
+static void prepare_sampled_images(const GrProcessor& processor, GrVkGpu* gpu) {
+    for (int i = 0; i < processor.numTextures(); ++i) {
+        const GrTextureAccess& texAccess = processor.textureAccess(i);
+        GrVkTexture* vkTexture = static_cast<GrVkTexture*>(processor.texture(i));
+        SkASSERT(vkTexture);
 
-            // We may need to resolve the texture first if it is also a render target
-            GrVkRenderTarget* texRT = static_cast<GrVkRenderTarget*>(vkTexture->asRenderTarget());
-            if (texRT) {
-                gpu->onResolveRenderTarget(texRT);
+        // We may need to resolve the texture first if it is also a render target
+        GrVkRenderTarget* texRT = static_cast<GrVkRenderTarget*>(vkTexture->asRenderTarget());
+        if (texRT) {
+            gpu->onResolveRenderTarget(texRT);
+        }
+
+        const GrTextureParams& params = texAccess.getParams();
+        // Check if we need to regenerate any mip maps
+        if (GrTextureParams::kMipMap_FilterMode == params.filterMode()) {
+            if (vkTexture->texturePriv().mipMapsAreDirty()) {
+                gpu->generateMipmap(vkTexture);
+                vkTexture->texturePriv().dirtyMipMaps(false);
             }
+        }
 
-            const GrTextureParams& params = texAccess.getParams();
-            // Check if we need to regenerate any mip maps
-            if (GrTextureParams::kMipMap_FilterMode == params.filterMode()) {
-                if (vkTexture->texturePriv().mipMapsAreDirty()) {
-                    gpu->generateMipmap(vkTexture);
-                    vkTexture->texturePriv().dirtyMipMaps(false);
-                }
-            }
-
-            images[i] = vkTexture;
-        } while (++i < numTextures);
-
+        // TODO: If we ever decide to create the secondary command buffers ahead of time before we
+        // are actually going to submit them, we will need to track the sampled images and delay
+        // adding the layout change/barrier until we are ready to submit.
+        vkTexture->setImageLayout(gpu,
+                                  VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
+                                  VK_ACCESS_SHADER_READ_BIT,
+                                  VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT,
+                                  false);
     }
 }
 
 void GrVkGpuCommandBuffer::onDraw(const GrPipeline& pipeline,
                                   const GrPrimitiveProcessor& primProc,
                                   const GrMesh* meshes,
                                   int meshCount) {
     if (!meshCount) {
         return;
     }
     GrRenderTarget* rt = pipeline.getRenderTarget();
     GrVkRenderTarget* vkRT = static_cast<GrVkRenderTarget*>(rt);
     const GrVkRenderPass* renderPass = vkRT->simpleRenderPass();
     SkASSERT(renderPass);
 
-    append_sampled_images(primProc, fGpu, &fSampledImages);
+    prepare_sampled_images(primProc, fGpu);
     for (int i = 0; i < pipeline.numFragmentProcessors(); ++i) {
-        append_sampled_images(pipeline.getFragmentProcessor(i), fGpu, &fSampledImages);
+        prepare_sampled_images(pipeline.getFragmentProcessor(i), fGpu);
     }
-    append_sampled_images(pipeline.getXferProcessor(), fGpu, &fSampledImages);
+    prepare_sampled_images(pipeline.getXferProcessor(), fGpu);
 
     GrPrimitiveType primitiveType = meshes[0].primitiveType();
     sk_sp<GrVkPipelineState> pipelineState = this->prepareDrawState(pipeline,
                                                                     primProc,
                                                                     primitiveType,
                                                                     *renderPass);
     if (!pipelineState) {
         return;
     }
 
@@ skipping 39 matching lines @@
             fGpu->stats()->incNumDraws();
         } while ((nonIdxMesh = iter.next()));
     }
 
     // Technically we don't have to call this here (since there is a safety check in
     // pipelineState:setData but this will allow for quicker freeing of resources if the
     // pipelineState sits in a cache for a while.
     pipelineState->freeTempResources(fGpu);
 }