Vulkan: Defer the depthStencil buffer layout change to endRenderPass

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -4042,7 +4042,7 @@ angle::Result ContextVk::updateActiveTextures(const gl::Context *context)
 
             if (hasStartedRenderPass())
             {
-                if (!mDrawFramebuffer->isReadOnlyDepthMode())
+                if (!mRenderPassCommands->isReadOnlyDepthMode())
                 {
                     // To enter depth feedback loop, we must flush and start a new renderpass.
                     // Otherwise it will stick with writable layout and cause validation error.
@@ -4050,8 +4050,7 @@ angle::Result ContextVk::updateActiveTextures(const gl::Context *context)
                 }
                 else
                 {
-                    ANGLE_TRY(mDrawFramebuffer->updateRenderPassReadOnlyDepthMode(
-                        this, mRenderPassCommands));
+                    mDrawFramebuffer->updateRenderPassReadOnlyDepthMode(this, mRenderPassCommands);
                 }
             }
 
@@ -4573,13 +4572,6 @@ angle::Result ContextVk::onImageRead(VkImageAspectFlags aspectFlags,
     ASSERT(!image->isReleasedToExternal());
     ASSERT(image->getImageSerial().valid());
 
-    // Layout transitions for images used in the render pass are handled especially.  This function
-    // is only called when the image is used outside the render pass.  As such, if the image is used
-    // inside the render pass, its layout is necessarily different from imageLayout, and thus a
-    // layout transition is necessary (and the render pass has to break).
-    ASSERT(image->isReadBarrierNecessary(imageLayout) ||
-           !(mRenderPassCommands->started() && mRenderPassCommands->usesImageInRenderPass(*image)));
-
     // Note that different read methods are not compatible. A shader read uses a different layout
     // than a transfer read. So we cannot support simultaneous read usage as easily as for Buffers.
     // TODO: Don't close the render pass if the image was only used read-only in the render pass.
@@ -4636,22 +4628,18 @@ angle::Result ContextVk::startRenderPass(gl::Rectangle renderArea,
 {
     mGraphicsDirtyBits |= mNewGraphicsCommandBufferDirtyBits;
 
-    // We always start renderpass with proper depth stencil read only mode based on the current
-    // depth stencil state.
-    const gl::DepthStencilState &dsState = mState.getDepthStencilState();
-    vk::ResourceAccess depthAccess       = GetDepthAccess(dsState);
-    vk::ResourceAccess stencilAccess     = GetStencilAccess(dsState);
-    bool readOnlyDepthMode =
-        depthAccess != vk::ResourceAccess::Write && stencilAccess != vk::ResourceAccess::Write;
-
-    ANGLE_TRY(mDrawFramebuffer->startNewRenderPass(this, readOnlyDepthMode, renderArea,
-                                                   &mRenderPassCommandBuffer));
+    ANGLE_TRY(mDrawFramebuffer->startNewRenderPass(this, renderArea, &mRenderPassCommandBuffer));
 
     ANGLE_TRY(resumeOcclusionQueryIfActive());
 
+    const gl::DepthStencilState &dsState = mState.getDepthStencilState();
+    vk::ResourceAccess depthAccess       = GetDepthAccess(dsState);
+    vk::ResourceAccess stencilAccess     = GetStencilAccess(dsState);
     mRenderPassCommands->onDepthAccess(depthAccess);
     mRenderPassCommands->onStencilAccess(stencilAccess);
 
+    mDrawFramebuffer->updateRenderPassReadOnlyDepthMode(this, mRenderPassCommands);
+
     if (commandBufferOut)
     {
         *commandBufferOut = mRenderPassCommandBuffer;
@@ -5088,8 +5076,7 @@ angle::Result ContextVk::updateRenderPassDepthStencilAccess()
                 mDrawFramebuffer->restoreDepthStencilDefinedContents();
             }
 
-            ANGLE_TRY(
-                mDrawFramebuffer->updateRenderPassReadOnlyDepthMode(this, mRenderPassCommands));
+            mDrawFramebuffer->updateRenderPassReadOnlyDepthMode(this, mRenderPassCommands);
         }
     }
 

src/libANGLE/renderer/vulkan/ContextVk.h

@@ -553,6 +553,12 @@ class ContextVk : public ContextImpl, public vk::Context
                                         vk::AliasingMode::Allowed, image);
     }
 
+    void onDepthStencilDraw(vk::ImageHelper *image, vk::ImageHelper *resolveImage)
+    {
+        ASSERT(mRenderPassCommands->started());
+        mRenderPassCommands->depthStencilImagesDraw(&mResourceUseList, image, resolveImage);
+    }
+
     void onImageHelperRelease(const vk::ImageHelper *image)
     {
         if (mRenderPassCommands->started())

src/libANGLE/renderer/vulkan/FramebufferVk.cpp

@@ -309,7 +309,6 @@ FramebufferVk::FramebufferVk(RendererVk *renderer,
       mBackbuffer(backbuffer),
       mFramebuffer(nullptr),
       mActiveColorComponents(0),
-      mReadOnlyDepthStencilMode(false),
       mReadOnlyDepthFeedbackLoopMode(false)
 {
     mReadPixelBuffer.init(renderer, VK_BUFFER_USAGE_TRANSFER_DST_BIT, kReadPixelsBufferAlignment,
@@ -1749,9 +1748,6 @@ angle::Result FramebufferVk::syncState(const gl::Context *context,
         return angle::Result::Continue;
     }
 
-    // Default to writable depth on any Framebuffer change.
-    mReadOnlyDepthStencilMode = false;
-
     // The FBO's new attachment may have changed the renderable area
     const gl::State &glState = context->getState();
     ANGLE_TRY(contextVk->updateScissor(glState));
@@ -1819,12 +1815,9 @@ void FramebufferVk::updateRenderPassDesc()
     RenderTargetVk *depthStencilRenderTarget = getDepthStencilRenderTarget();
     if (depthStencilRenderTarget)
     {
-        vk::ResourceAccess dsAccess =
-            mReadOnlyDepthStencilMode ? vk::ResourceAccess::ReadOnly : vk::ResourceAccess::Write;
-
         mRenderPassDesc.packDepthStencilAttachment(
             depthStencilRenderTarget->getImageForRenderPass().getFormat().intendedFormatID,
-            dsAccess);
+            vk::ResourceAccess::Write);
 
         // Add the resolve attachment, if any.
         if (depthStencilRenderTarget->hasResolveAttachment())
@@ -2154,7 +2147,7 @@ angle::Result FramebufferVk::clearWithLoadOp(ContextVk *contextVk,
             clearValue.depthStencil = clearDepthStencilValue;
             commands.updateRenderPassDepthStencilClear(dsAspectFlags, clearValue);
             // If we were in depth read only mode, we must change to write mode
-            ANGLE_TRY(updateRenderPassReadOnlyDepthMode(contextVk, &commands));
+            updateRenderPassReadOnlyDepthMode(contextVk, &commands);
         }
     }
     else
@@ -2237,7 +2230,7 @@ angle::Result FramebufferVk::clearWithCommand(
         attachments.emplace_back(VkClearAttachment{dsAspectFlags, 0, dsClearValue});
         // Because we may have changed the depth stencil access mode, update read only depth mode
         // now.
-        ANGLE_TRY(updateRenderPassReadOnlyDepthMode(contextVk, renderpassCommands));
+        updateRenderPassReadOnlyDepthMode(contextVk, renderpassCommands);
     }
 
     VkClearRect rect                           = {};
@@ -2260,7 +2253,6 @@ angle::Result FramebufferVk::getSamplePosition(const gl::Context *context,
 }
 
 angle::Result FramebufferVk::startNewRenderPass(ContextVk *contextVk,
-                                                bool readOnlyDepthMode,
                                                 const gl::Rectangle &renderArea,
                                                 vk::CommandBuffer **commandBufferOut)
 {
@@ -2466,22 +2458,6 @@ angle::Result FramebufferVk::startNewRenderPass(ContextVk *contextVk,
         renderPassAttachmentOps.setOps(depthStencilAttachmentIndex, depthLoadOp, depthStoreOp);
         renderPassAttachmentOps.setStencilOps(depthStencilAttachmentIndex, stencilLoadOp,
                                               stencilStoreOp);
-
-        // We can only start the renderpass in read only mode if it is requested to be read only and
-        // we are not doing clear.
-        bool depthStencilReadOnly =
-            readOnlyDepthMode && !depthStencilRenderTarget->hasResolveAttachment() &&
-            renderPassAttachmentOps[depthStencilAttachmentIndex].loadOp !=
-                VK_ATTACHMENT_LOAD_OP_CLEAR &&
-            renderPassAttachmentOps[depthStencilAttachmentIndex].stencilLoadOp !=
-                VK_ATTACHMENT_LOAD_OP_CLEAR;
-        setReadOnlyDepthMode(depthStencilReadOnly);
-
-        vk::ImageLayout dsLayout = mReadOnlyDepthStencilMode
-                                       ? vk::ImageLayout::DepthStencilReadOnly
-                                       : vk::ImageLayout::DepthStencilAttachment;
-
-        renderPassAttachmentOps.setLayouts(depthStencilAttachmentIndex, dsLayout, dsLayout);
     }
 
     // If render pass description is changed, the previous render pass desc is no longer compatible.
@@ -2524,7 +2500,8 @@ angle::Result FramebufferVk::startNewRenderPass(ContextVk *contextVk,
         // tracking content valid very loosely here that as long as it is attached, it assumes will
         // have valid content. The only time it has undefined content is between swap and
         // startNewRenderPass
-        depthStencilRenderTarget->onDepthStencilDraw(contextVk, mReadOnlyDepthStencilMode);
+        // The actual layout determination will be deferred until endRenderPass time
+        depthStencilRenderTarget->onDepthStencilDraw(contextVk);
     }
 
     if (unresolveColorMask.any() || unresolveDepth || unresolveStencil)
@@ -2663,50 +2640,19 @@ angle::Result FramebufferVk::flushDeferredClears(ContextVk *contextVk,
     return contextVk->startRenderPass(renderArea, nullptr);
 }
 
-void FramebufferVk::setReadOnlyDepthMode(bool readOnlyDepthEnabled)
-{
-    if (mReadOnlyDepthStencilMode != readOnlyDepthEnabled)
-    {
-        mReadOnlyDepthStencilMode = readOnlyDepthEnabled;
-
-        ASSERT(getDepthStencilRenderTarget());
-        vk::ResourceAccess dsAccess =
-            isReadOnlyDepthMode() ? vk::ResourceAccess::ReadOnly : vk::ResourceAccess::Write;
-        ASSERT(mRenderPassDesc.hasDepthStencilAttachment());
-        mRenderPassDesc.updateDepthStencilAccess(dsAccess);
-    }
-}
-
-angle::Result FramebufferVk::updateRenderPassReadOnlyDepthMode(ContextVk *contextVk,
-                                                               vk::CommandBufferHelper *renderPass)
+void FramebufferVk::updateRenderPassReadOnlyDepthMode(ContextVk *contextVk,
+                                                      vk::CommandBufferHelper *renderPass)
 {
-    ASSERT(getDepthStencilRenderTarget());
-
-    bool readOnlyDepthStencil =
-        !getDepthStencilRenderTarget()->hasResolveAttachment() &&
+    bool readOnlyDepthStencilMode =
+        getDepthStencilRenderTarget() && !getDepthStencilRenderTarget()->hasResolveAttachment() &&
         (mReadOnlyDepthFeedbackLoopMode || !renderPass->hasDepthStencilWriteOrClear());
-    if (readOnlyDepthStencil == mReadOnlyDepthStencilMode)
-    {
-        return angle::Result::Continue;
-    }
 
     // If readOnlyDepthStencil is false, we are switching out of read only mode due to depth write.
     // We must not be in the read only feedback loop mode because the logic in
     // ContextVk::updateRenderPassDepthStencilAccess() should ensure we end the previous renderpass
     // and a new renderpass will start with feedback loop disabled.
-    ASSERT(readOnlyDepthStencil || !mReadOnlyDepthFeedbackLoopMode);
-
-    setReadOnlyDepthMode(readOnlyDepthStencil);
-
-    // When we toggle read/write mode, we must insert a layout transition.
-    getDepthStencilRenderTarget()->onDepthStencilDraw(contextVk, readOnlyDepthStencil);
+    ASSERT(readOnlyDepthStencilMode || !mReadOnlyDepthFeedbackLoopMode);
 
-    vk::Framebuffer *currentFramebuffer = nullptr;
-    ANGLE_TRY(getFramebuffer(contextVk, &currentFramebuffer, nullptr));
-
-    renderPass->updateStartedRenderPassWithDepthMode(*currentFramebuffer, mRenderPassDesc,
-                                                     readOnlyDepthStencil);
-
-    return angle::Result::Continue;
+    renderPass->updateStartedRenderPassWithDepthMode(readOnlyDepthStencilMode);
 }
 }  // namespace rx

src/libANGLE/renderer/vulkan/FramebufferVk.h

@@ -116,7 +116,6 @@ class FramebufferVk : public FramebufferImpl
     RenderTargetVk *getColorReadRenderTarget() const;
 
     angle::Result startNewRenderPass(ContextVk *contextVk,
-                                     bool readOnlyDepthMode,
                                      const gl::Rectangle &renderArea,
                                      vk::CommandBuffer **commandBufferOut);
     void restoreDepthStencilDefinedContents();
@@ -130,8 +129,6 @@ class FramebufferVk : public FramebufferImpl
                                  vk::Framebuffer **framebufferOut,
                                  const vk::ImageView *resolveImageViewIn);
 
-    bool isReadOnlyDepthMode() const { return mReadOnlyDepthStencilMode; }
-
     bool hasDeferredClears() const { return !mDeferredClears.empty(); }
     angle::Result flushDeferredClears(ContextVk *contextVk, const gl::Rectangle &renderArea);
     void setReadOnlyDepthFeedbackLoopMode(bool readOnlyDepthFeedbackModeEnabled)
@@ -139,8 +136,8 @@ class FramebufferVk : public FramebufferImpl
         mReadOnlyDepthFeedbackLoopMode = readOnlyDepthFeedbackModeEnabled;
     }
     bool isReadOnlyDepthFeedbackLoopMode() const { return mReadOnlyDepthFeedbackLoopMode; }
-    angle::Result updateRenderPassReadOnlyDepthMode(ContextVk *contextVk,
-                                                    vk::CommandBufferHelper *renderPass);
+    void updateRenderPassReadOnlyDepthMode(ContextVk *contextVk,
+                                           vk::CommandBufferHelper *renderPass);
 
   private:
     FramebufferVk(RendererVk *renderer,
@@ -232,8 +229,6 @@ class FramebufferVk : public FramebufferImpl
                                       vk::ImageViewSubresourceSerial resolveImageViewSerial);
     void removeColorResolveAttachment(uint32_t colorIndexGL);
 
-    void setReadOnlyDepthMode(bool readOnlyDepthEnabled);
-
     WindowSurfaceVk *mBackbuffer;
 
     vk::RenderPassDesc mRenderPassDesc;
@@ -257,8 +252,6 @@ class FramebufferVk : public FramebufferImpl
 
     vk::ClearValuesArray mDeferredClears;
 
-    // True if depth stencil buffer is read only.
-    bool mReadOnlyDepthStencilMode;
     // Tracks if we are in depth feedback loop. Depth read only feedback loop is a special kind of
     // depth stencil read only mode. When we are in feedback loop, we must flush renderpass to exit
     // the loop instead of update the layout.

src/libANGLE/renderer/vulkan/RenderTargetVk.cpp

@@ -107,29 +107,12 @@ void RenderTargetVk::onColorDraw(ContextVk *contextVk)
     mContentDefined = true;
 }
 
-void RenderTargetVk::onDepthStencilDraw(ContextVk *contextVk, bool isReadOnly)
+void RenderTargetVk::onDepthStencilDraw(ContextVk *contextVk)
 {
     const angle::Format &format = mImage->getFormat().actualImageFormat();
     ASSERT(format.hasDepthOrStencilBits());
-    VkImageAspectFlags aspectFlags = vk::GetDepthStencilAspectFlags(format);
-
-    if (isReadOnly)
-    {
-        ASSERT(!mResolveImage);
-        contextVk->onImageRenderPassRead(aspectFlags, vk::ImageLayout::DepthStencilReadOnly,
-                                         mImage);
-    }
-    else
-    {
-        contextVk->onImageRenderPassWrite(aspectFlags, vk::ImageLayout::DepthStencilAttachment,
-                                          mImage);
-        if (mResolveImage)
-        {
-            contextVk->onImageRenderPassWrite(
-                aspectFlags, vk::ImageLayout::DepthStencilResolveAttachment, mResolveImage);
-        }
-    }
 
+    contextVk->onDepthStencilDraw(mImage, mResolveImage);
     retainImageViews(contextVk);
 
     mContentDefined = true;

src/libANGLE/renderer/vulkan/RenderTargetVk.h

@@ -67,7 +67,7 @@ class RenderTargetVk final : public FramebufferAttachmentRenderTarget
 
     // Note: RenderTargets should be called in order, with the depth/stencil onRender last.
     void onColorDraw(ContextVk *contextVk);
-    void onDepthStencilDraw(ContextVk *contextVk, bool isReadOnly);
+    void onDepthStencilDraw(ContextVk *contextVk);
 
     vk::ImageHelper &getImageForRenderPass();
     const vk::ImageHelper &getImageForRenderPass() const;

src/libANGLE/renderer/vulkan/UtilsVk.cpp

@@ -1413,7 +1413,7 @@ angle::Result UtilsVk::clearFramebuffer(ContextVk *contextVk,
 
         // We may have changed depth stencil access mode, so update read only depth stencil mode
         // here.
-        ANGLE_TRY(framebuffer->updateRenderPassReadOnlyDepthMode(contextVk, renderpassCommands));
+        framebuffer->updateRenderPassReadOnlyDepthMode(contextVk, renderpassCommands);
     }
 
     ImageClearShaderParams shaderParams;
@@ -1666,7 +1666,7 @@ angle::Result UtilsVk::blitResolveImpl(ContextVk *contextVk,
     pipelineDesc.setScissor(gl_vk::GetRect(params.blitArea));
 
     vk::CommandBuffer *commandBuffer;
-    ANGLE_TRY(framebuffer->startNewRenderPass(contextVk, false, params.blitArea, &commandBuffer));
+    ANGLE_TRY(framebuffer->startNewRenderPass(contextVk, params.blitArea, &commandBuffer));
     contextVk->onImageRenderPassRead(src->getAspectFlags(), vk::ImageLayout::FragmentShaderReadOnly,
                                      src);
 

src/libANGLE/renderer/vulkan/vk_helpers.cpp

@@ -618,18 +618,20 @@ CommandBufferHelper::CommandBufferHelper()
       mCounter(0),
       mClearValues{},
       mRenderPassStarted(false),
-      mForceIndividualBarriers(false),
       mTransformFeedbackCounterBuffers{},
       mValidTransformFeedbackBufferCount(0),
       mRebindTransformFeedbackBuffers(false),
       mIsRenderPassCommandBuffer(false),
+      mReadOnlyDepthStencilMode(false),
       mDepthAccess(ResourceAccess::Unused),
       mStencilAccess(ResourceAccess::Unused),
       mDepthCmdSizeInvalidated(kInfiniteCmdSize),
       mDepthCmdSizeDisabled(kInfiniteCmdSize),
       mStencilCmdSizeInvalidated(kInfiniteCmdSize),
       mStencilCmdSizeDisabled(kInfiniteCmdSize),
-      mDepthStencilAttachmentIndex(kAttachmentIndexInvalid)
+      mDepthStencilAttachmentIndex(kAttachmentIndexInvalid),
+      mDepthStencilImage(nullptr),
+      mDepthStencilResolveImage(nullptr)
 {}
 
 CommandBufferHelper::~CommandBufferHelper()
@@ -768,6 +770,31 @@ void CommandBufferHelper::imageWrite(ResourceUseList *resourceUseList,
     }
 }
 
+void CommandBufferHelper::depthStencilImagesDraw(ResourceUseList *resourceUseList,
+                                                 ImageHelper *image,
+                                                 ImageHelper *resolveImage)
+{
+    ASSERT(mIsRenderPassCommandBuffer);
+    ASSERT(!usesImageInRenderPass(*image));
+    ASSERT(!resolveImage || !usesImageInRenderPass(*resolveImage));
+
+    // Because depthStencil buffer's read/write property can change while we build renderpass, we
+    // defer the image layout changes until endRenderPass time or when images going away so that we
+    // only insert layout change barrier once.
+    image->retain(resourceUseList);
+    image->onWrite();
+    mRenderPassUsedImages.insert(image->getImageSerial().getValue());
+    mDepthStencilImage = image;
+
+    if (resolveImage)
+    {
+        resolveImage->retain(resourceUseList);
+        resolveImage->onWrite();
+        mRenderPassUsedImages.insert(resolveImage->getImageSerial().getValue());
+        mDepthStencilResolveImage = resolveImage;
+    }
+}
+
 bool CommandBufferHelper::onDepthAccess(ResourceAccess access)
 {
     // Update the access for optimizing this render pass's loadOp
@@ -838,20 +865,7 @@ void CommandBufferHelper::executeBarriers(ContextVk *contextVk, PrimaryCommandBu
         return;
     }
 
-    if (mForceIndividualBarriers)
-    {
-        // Note: ideally we could merge double barriers into a single barrier (or even completely
-        // eliminate them in some cases). This is a bit trickier to manage than splitting barriers
-        // into single calls. It should only affect Framebuffer transitions.
-        // TODO: Investigate merging barriers. http://anglebug.com/4976
-        for (PipelineStage pipelineStage : mask)
-        {
-            PipelineBarrier &barrier = mPipelineBarriers[pipelineStage];
-            barrier.executeIndividually(primary);
-        }
-        mForceIndividualBarriers = false;
-    }
-    else if (contextVk->getFeatures().preferAggregateBarrierCalls.enabled)
+    if (contextVk->getFeatures().preferAggregateBarrierCalls.enabled)
     {
         PipelineStagesMask::Iterator iter = mask.begin();
         PipelineBarrier &barrier          = mPipelineBarriers[*iter];
@@ -872,11 +886,84 @@ void CommandBufferHelper::executeBarriers(ContextVk *contextVk, PrimaryCommandBu
     mPipelineBarrierMask.reset();
 }
 
+void CommandBufferHelper::finalizeDepthStencilImageLayout()
+{
+    ASSERT(mIsRenderPassCommandBuffer);
+    ASSERT(mDepthStencilImage);
+
+    // Do depth stencil layout change.
+    ImageLayout imageLayout;
+    bool barrierRequired;
+
+    if (mReadOnlyDepthStencilMode)
+    {
+        imageLayout = ImageLayout::DepthStencilReadOnly;
+        mRenderPassDesc.updateDepthStencilAccess(ResourceAccess::ReadOnly);
+        barrierRequired = mDepthStencilImage->isReadBarrierNecessary(imageLayout);
+    }
+    else
+    {
+        // Write always requires a barrier
+        imageLayout = ImageLayout::DepthStencilAttachment;
+        mRenderPassDesc.updateDepthStencilAccess(ResourceAccess::Write);
+        barrierRequired = true;
+    }
+
+    mAttachmentOps.setLayouts(mDepthStencilAttachmentIndex, imageLayout, imageLayout);
+
+    if (barrierRequired)
+    {
+        const angle::Format &format = mDepthStencilImage->getFormat().actualImageFormat();
+        ASSERT(format.hasDepthOrStencilBits());
+        VkImageAspectFlags aspectFlags = GetDepthStencilAspectFlags(format);
+
+        PipelineStage barrierIndex = kImageMemoryBarrierData[imageLayout].barrierIndex;
+        ASSERT(barrierIndex != PipelineStage::InvalidEnum);
+        PipelineBarrier *barrier = &mPipelineBarriers[barrierIndex];
+
+        if (mDepthStencilImage->updateLayoutAndBarrier(aspectFlags, imageLayout, barrier))
+        {
+            mPipelineBarrierMask.set(barrierIndex);
+        }
+    }
+}
+
+void CommandBufferHelper::finalizeDepthStencilResolveImageLayout()
+{
+    ASSERT(mIsRenderPassCommandBuffer);
+    ASSERT(mDepthStencilImage);
+    ASSERT(!mReadOnlyDepthStencilMode);
+
+    ImageLayout imageLayout     = ImageLayout::DepthStencilResolveAttachment;
+    const angle::Format &format = mDepthStencilResolveImage->getFormat().actualImageFormat();
+    ASSERT(format.hasDepthOrStencilBits());
+    VkImageAspectFlags aspectFlags = GetDepthStencilAspectFlags(format);
+
+    PipelineStage barrierIndex = kImageMemoryBarrierData[imageLayout].barrierIndex;
+    ASSERT(barrierIndex != PipelineStage::InvalidEnum);
+    PipelineBarrier *barrier = &mPipelineBarriers[barrierIndex];
+
+    if (mDepthStencilResolveImage->updateLayoutAndBarrier(aspectFlags, imageLayout, barrier))
+    {
+        mPipelineBarrierMask.set(barrierIndex);
+    }
+}
+
 void CommandBufferHelper::onImageHelperRelease(const vk::ImageHelper *image)
 {
     ASSERT(mIsRenderPassCommandBuffer);
-    // TODO: https://issuetracker.google.com/168953278 We will use this to finalize image layout
-    // transition
+
+    if (mDepthStencilImage == image)
+    {
+        finalizeDepthStencilImageLayout();
+        mDepthStencilImage = nullptr;
+    }
+
+    if (mDepthStencilResolveImage == image)
+    {
+        finalizeDepthStencilResolveImageLayout();
+        mDepthStencilResolveImage = nullptr;
+    }
 }
 
 void CommandBufferHelper::beginRenderPass(const Framebuffer &framebuffer,
@@ -894,32 +981,14 @@ void CommandBufferHelper::beginRenderPass(const Framebuffer &framebuffer,
     mAttachmentOps               = renderPassAttachmentOps;
     mDepthStencilAttachmentIndex = depthStencilAttachmentIndex;
     mFramebuffer.setHandle(framebuffer.getHandle());
-    mRenderArea              = renderArea;
-    mClearValues             = clearValues;
-    *commandBufferOut        = &mCommandBuffer;
-    mForceIndividualBarriers = false;
+    mRenderArea       = renderArea;
+    mClearValues      = clearValues;
+    *commandBufferOut = &mCommandBuffer;
 
     mRenderPassStarted = true;
     mCounter++;
 }
 
-void CommandBufferHelper::updateStartedRenderPassWithDepthMode(const Framebuffer &framebuffer,
-                                                               const RenderPassDesc &renderPassDesc,
-                                                               bool readOnlyDepth)
-{
-    ASSERT(mIsRenderPassCommandBuffer);
-    ASSERT(mRenderPassStarted);
-
-    mRenderPassDesc = renderPassDesc;
-    ImageLayout depthStencilLayout =
-        readOnlyDepth ? ImageLayout::DepthStencilReadOnly : ImageLayout::DepthStencilAttachment;
-    mAttachmentOps.setLayouts(mDepthStencilAttachmentIndex, depthStencilLayout, depthStencilLayout);
-    mFramebuffer.setHandle(framebuffer.getHandle());
-
-    // Barrier aggregation messes up with RenderPass restarting.
-    mForceIndividualBarriers = true;
-}
-
 void CommandBufferHelper::endRenderPass(ContextVk *contextVk)
 {
     if (mDepthStencilAttachmentIndex == kAttachmentIndexInvalid)
@@ -927,8 +996,17 @@ void CommandBufferHelper::endRenderPass(ContextVk *contextVk)
         return;
     }
 
-    PackedAttachmentOpsDesc &dsOps = mAttachmentOps[mDepthStencilAttachmentIndex];
+    // Do depth stencil layout change.
+    if (mDepthStencilImage)
+    {
+        finalizeDepthStencilImageLayout();
+    }
+    if (mDepthStencilResolveImage)
+    {
+        finalizeDepthStencilResolveImageLayout();
+    }
 
+    PackedAttachmentOpsDesc &dsOps = mAttachmentOps[mDepthStencilAttachmentIndex];
     // Depth/Stencil buffer optimizations:
     //
     // First, if the attachment is invalidated, skip the store op.
@@ -1171,6 +1249,9 @@ void CommandBufferHelper::reset()
         mStencilCmdSizeDisabled            = kInfiniteCmdSize;
         mDepthStencilAttachmentIndex       = kAttachmentIndexInvalid;
         mRenderPassUsedImages.clear();
+        mDepthStencilImage        = nullptr;
+        mDepthStencilResolveImage = nullptr;
+        mReadOnlyDepthStencilMode = false;
     }
     // This state should never change for non-renderPass command buffer
     ASSERT(mRenderPassStarted == false);

src/libANGLE/renderer/vulkan/vk_helpers.h

@@ -950,6 +950,10 @@ class CommandBufferHelper : angle::NonCopyable
                     AliasingMode aliasingMode,
                     ImageHelper *image);
 
+    void depthStencilImagesDraw(ResourceUseList *resourceUseList,
+                                ImageHelper *image,
+                                ImageHelper *resolveImage);
+
     CommandBuffer &getCommandBuffer() { return mCommandBuffer; }
 
     angle::Result flushToPrimary(ContextVk *contextVk, PrimaryCommandBuffer *primary);
@@ -999,9 +1003,12 @@ class CommandBufferHelper : angle::NonCopyable
 
     void endRenderPass(ContextVk *contextVk);
 
-    void updateStartedRenderPassWithDepthMode(const Framebuffer &framebuffer,
-                                              const RenderPassDesc &renderPassDesc,
-                                              bool readOnlyDepth);
+    void updateStartedRenderPassWithDepthMode(bool readOnlyDepthStencilMode)
+    {
+        ASSERT(mIsRenderPassCommandBuffer);
+        ASSERT(mRenderPassStarted);
+        mReadOnlyDepthStencilMode = readOnlyDepthStencilMode;
+    }
 
     void beginTransformFeedback(size_t validBufferCount,
                                 const VkBuffer *counterBuffers,
@@ -1109,6 +1116,8 @@ class CommandBufferHelper : angle::NonCopyable
                    VK_ATTACHMENT_LOAD_OP_CLEAR;
     }
 
+    bool isReadOnlyDepthMode() const { return mReadOnlyDepthStencilMode; }
+
   private:
     void addCommandDiagnostics(ContextVk *contextVk);
 
@@ -1116,6 +1125,9 @@ class CommandBufferHelper : angle::NonCopyable
                               uint32_t *cmdCountInvalidated,
                               uint32_t *cmdCountDisabled);
 
+    void finalizeDepthStencilImageLayout();
+    void finalizeDepthStencilResolveImageLayout();
+
     // Allocator used by this class. Using a pool allocator per CBH to avoid threading issues
     //  that occur w/ shared allocator between multiple CBHs.
     angle::PoolAllocator mAllocator;
@@ -1133,7 +1145,6 @@ class CommandBufferHelper : angle::NonCopyable
     gl::Rectangle mRenderArea;
     PackedClearValuesArray mClearValues;
     bool mRenderPassStarted;
-    bool mForceIndividualBarriers;
 
     // Transform feedback state
     gl::TransformFeedbackBuffersArray<VkBuffer> mTransformFeedbackCounterBuffers;
@@ -1141,6 +1152,7 @@ class CommandBufferHelper : angle::NonCopyable
     bool mRebindTransformFeedbackBuffers;
 
     bool mIsRenderPassCommandBuffer;
+    bool mReadOnlyDepthStencilMode;
 
     // State tracking for the maximum (Write been the highest) depth access during the entire
     // renderpass. Note that this does not include VK_ATTACHMENT_LOAD_OP_CLEAR which is tracked
@@ -1165,6 +1177,9 @@ class CommandBufferHelper : angle::NonCopyable
     // Images have unique layouts unlike buffers therefore we don't support multi-read.
     angle::FastIntegerMap<BufferAccess> mUsedBuffers;
     angle::FastIntegerSet mRenderPassUsedImages;
+
+    ImageHelper *mDepthStencilImage;
+    ImageHelper *mDepthStencilResolveImage;
 };
 
 // Imagine an image going through a few layout transitions: