Vulkan: Command graph linearization (Step 4).

src/libANGLE/TransformFeedback.cpp

@@ -326,4 +326,9 @@ void TransformFeedback::onBindingChanged(const Context *context, bool bound)
         }
     }
 }
+
+const std::vector<OffsetBindingPointer<Buffer>> &TransformFeedback::getIndexedBuffers() const
+{
+    return mState.mIndexedBuffers;
+}
 }  // namespace gl

src/libANGLE/TransformFeedback.h

@@ -94,6 +94,7 @@ class TransformFeedback final : public RefCountObject<TransformFeedbackID>, publ
                                     size_t size);
     const OffsetBindingPointer<Buffer> &getIndexedBuffer(size_t index) const;
     size_t getIndexedBufferCount() const;
+    const std::vector<OffsetBindingPointer<Buffer>> &getIndexedBuffers() const;
 
     GLsizeiptr getVerticesDrawn() const { return mState.getVerticesDrawn(); }
     GLsizeiptr getPrimitivesDrawn() const { return mState.getPrimitivesDrawn(); }

src/libANGLE/renderer/vulkan/CommandGraph.cpp

@@ -168,26 +168,6 @@ const char *GetStoreOpShorthand(uint32_t storeOp)
     }
 }
 
-void MakeDebugUtilsLabel(GLenum source, const char *marker, VkDebugUtilsLabelEXT *label)
-{
-    static constexpr angle::ColorF kLabelColors[6] = {
-        angle::ColorF(1.0f, 0.5f, 0.5f, 1.0f),  // DEBUG_SOURCE_API
-        angle::ColorF(0.5f, 1.0f, 0.5f, 1.0f),  // DEBUG_SOURCE_WINDOW_SYSTEM
-        angle::ColorF(0.5f, 0.5f, 1.0f, 1.0f),  // DEBUG_SOURCE_SHADER_COMPILER
-        angle::ColorF(0.7f, 0.7f, 0.7f, 1.0f),  // DEBUG_SOURCE_THIRD_PARTY
-        angle::ColorF(0.5f, 0.8f, 0.9f, 1.0f),  // DEBUG_SOURCE_APPLICATION
-        angle::ColorF(0.9f, 0.8f, 0.5f, 1.0f),  // DEBUG_SOURCE_OTHER
-    };
-
-    int colorIndex = source - GL_DEBUG_SOURCE_API;
-    ASSERT(colorIndex >= 0 && static_cast<size_t>(colorIndex) < ArraySize(kLabelColors));
-
-    label->sType      = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
-    label->pNext      = nullptr;
-    label->pLabelName = marker;
-    kLabelColors[colorIndex].writeData(label->color);
-}
-
 constexpr VkSubpassContents kRenderPassContents =
     CommandBuffer::ExecutesInline() ? VK_SUBPASS_CONTENTS_INLINE
                                     : VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS;

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -1244,7 +1244,8 @@ ANGLE_INLINE angle::Result ContextVk::handleDirtyShaderResourcesImpl(
     if (mProgram->hasUniformBuffers() || mProgram->hasStorageBuffers() ||
         mProgram->hasAtomicCounterBuffers() || mProgram->hasImages())
     {
-        ANGLE_TRY(mProgram->updateShaderResourcesDescriptorSet(this, recorder));
+        ANGLE_TRY(mProgram->updateShaderResourcesDescriptorSet(this, &mResourceUseList,
+                                                               &mRenderPassCommands, recorder));
     }
     return angle::Result::Continue;
 }
@@ -1268,6 +1269,25 @@ angle::Result ContextVk::handleDirtyGraphicsTransformFeedbackBuffersEmulation(
 {
     if (mProgram->hasTransformFeedbackOutput() && mState.isTransformFeedbackActive())
     {
+        if (!commandGraphEnabled())
+        {
+            size_t bufferCount = mProgram->getState().getTransformFeedbackBufferCount();
+            const std::vector<gl::OffsetBindingPointer<gl::Buffer>> &xfbBuffers =
+                mState.getCurrentTransformFeedback()->getIndexedBuffers();
+
+            for (size_t bufferIndex = 0; bufferIndex < bufferCount; ++bufferIndex)
+            {
+                const gl::OffsetBindingPointer<gl::Buffer> &xfbBuffer = xfbBuffers[bufferIndex];
+                gl::Buffer *buffer                                    = xfbBuffer.get();
+                ASSERT(buffer != nullptr);
+                BufferVk *bufferVk             = vk::GetImpl(buffer);
+                vk::BufferHelper &bufferHelper = bufferVk->getBuffer();
+
+                mRenderPassCommands.bufferWrite(
+                    &mResourceUseList, VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, &bufferHelper);
+            }
+        }
+
         ANGLE_TRY(mProgram->updateTransformFeedbackDescriptorSet(
             this, mDrawFramebuffer->getFramebuffer()));
     }
@@ -1287,15 +1307,24 @@ angle::Result ContextVk::handleDirtyGraphicsTransformFeedbackBuffersExtension(
     size_t bufferCount = mProgram->getState().getTransformFeedbackBufferCount();
     gl::TransformFeedbackBuffersArray<VkBuffer> bufferHandles;
 
+    const std::vector<gl::OffsetBindingPointer<gl::Buffer>> &xfbBuffers =
+        mState.getCurrentTransformFeedback()->getIndexedBuffers();
+
     for (bufferIndex = 0; bufferIndex < bufferCount; ++bufferIndex)
     {
-        const gl::OffsetBindingPointer<gl::Buffer> &bufferBinding =
-            mState.getCurrentTransformFeedback()->getIndexedBuffer(bufferIndex);
+        const gl::OffsetBindingPointer<gl::Buffer> &bufferBinding = xfbBuffers[bufferIndex];
         gl::Buffer *buffer                                        = bufferBinding.get();
         ASSERT(buffer != nullptr);
+        BufferVk *bufferVk = vk::GetImpl(buffer);
 
-        vk::BufferHelper &bufferHelper = vk::GetImpl(buffer)->getBuffer();
+        vk::BufferHelper &bufferHelper = bufferVk->getBuffer();
         bufferHandles[bufferIndex]     = bufferHelper.getBuffer().getHandle();
+
+        if (!commandGraphEnabled())
+        {
+            mRenderPassCommands.bufferWrite(
+                &mResourceUseList, VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT, &bufferHelper);
+        }
     }
 
     const TransformFeedbackBufferRange &xfbBufferRangeExtension =
@@ -1305,8 +1334,11 @@ angle::Result ContextVk::handleDirtyGraphicsTransformFeedbackBuffersExtension(
         static_cast<uint32_t>(bufferCount), bufferHandles.data(),
         xfbBufferRangeExtension.offsets.data(), xfbBufferRangeExtension.sizes.data());
 
+    if (commandGraphEnabled())
+    {
         vk::FramebufferHelper *framebuffer = mDrawFramebuffer->getFramebuffer();
         transformFeedbackVk->addFramebufferDependency(this, mProgram->getState(), framebuffer);
+    }
 
     return angle::Result::Continue;
 }
@@ -1326,8 +1358,17 @@ angle::Result ContextVk::handleDirtyGraphicsTransformFeedbackState(const gl::Con
 
     vk::FramebufferHelper *framebuffer = mDrawFramebuffer->getFramebuffer();
     bool rebindBuffer = transformFeedbackVk->getTransformFeedbackBufferRebindState();
+
+    if (commandGraphEnabled())
+    {
         framebuffer->setActiveTransformFeedbackInfo(bufferCount, counterBufferHandles.data(),
                                                     rebindBuffer);
+    }
+    else
+    {
+        mRenderPassCommands.beginTransformFeedback(bufferCount, counterBufferHandles.data(),
+                                                   rebindBuffer);
+    }
 
     transformFeedbackVk->unsetTransformFeedbackBufferRebindState();
 
@@ -2181,8 +2222,15 @@ angle::Result ContextVk::pushDebugGroup(const gl::Context *context,
     }
     else
     {
-        // TODO(jmadill): http://anglebug.com/4029
-        UNIMPLEMENTED();
+        if (vkCmdInsertDebugUtilsLabelEXT)
+        {
+            vk::PrimaryCommandBuffer *primary;
+            ANGLE_TRY(getPrimaryCommandBuffer(&primary));
+
+            VkDebugUtilsLabelEXT label;
+            vk::MakeDebugUtilsLabel(source, message.c_str(), &label);
+            vkCmdInsertDebugUtilsLabelEXT(primary->getHandle(), &label);
+        }
     }
 
     return angle::Result::Continue;
@@ -2196,8 +2244,12 @@ angle::Result ContextVk::popDebugGroup(const gl::Context *context)
     }
     else
     {
-        // TODO(jmadill): http://anglebug.com/4029
-        UNIMPLEMENTED();
+        if (vkCmdEndDebugUtilsLabelEXT)
+        {
+            vk::PrimaryCommandBuffer *primary;
+            ANGLE_TRY(getPrimaryCommandBuffer(&primary));
+            vkCmdEndDebugUtilsLabelEXT(primary->getHandle());
+        }
     }
 
     return angle::Result::Continue;
@@ -3995,7 +4047,12 @@ void OutsideRenderPassCommandBuffer::reset()
 }
 
 RenderPassCommandBuffer::RenderPassCommandBuffer()
-    : mCounter(0), mClearValues{}, mRenderPassStarted(false)
+    : mCounter(0),
+      mClearValues{},
+      mRenderPassStarted(false),
+      mTransformFeedbackCounterBuffers{},
+      mValidTransformFeedbackBufferCount(0),
+      mRebindTransformFeedbackBuffers(false)
 {}
 
 RenderPassCommandBuffer::~RenderPassCommandBuffer()
@@ -4029,6 +4086,19 @@ void RenderPassCommandBuffer::beginRenderPass(const vk::Framebuffer &framebuffer
     mCounter++;
 }
 
+void RenderPassCommandBuffer::beginTransformFeedback(size_t validBufferCount,
+                                                     const VkBuffer *counterBuffers,
+                                                     bool rebindBuffer)
+{
+    mValidTransformFeedbackBufferCount = static_cast<uint32_t>(validBufferCount);
+    mRebindTransformFeedbackBuffers    = rebindBuffer;
+
+    for (size_t index = 0; index < validBufferCount; index++)
+    {
+        mTransformFeedbackCounterBuffers[index] = counterBuffers[index];
+    }
+}
+
 angle::Result RenderPassCommandBuffer::flushToPrimary(ContextVk *contextVk,
                                                       vk::PrimaryCommandBuffer *primary)
 {
@@ -4058,8 +4128,42 @@ angle::Result RenderPassCommandBuffer::flushToPrimary(ContextVk *contextVk,
 
     // Run commands inside the RenderPass.
     primary->beginRenderPass(beginInfo, VK_SUBPASS_CONTENTS_INLINE);
+
+    if (mValidTransformFeedbackBufferCount == 0)
+    {
         mCommandBuffer.executeCommands(primary->getHandle());
         primary->endRenderPass();
+    }
+    else
+    {
+        uint32_t numCounterBuffers =
+            (mRebindTransformFeedbackBuffers) ? 0 : mValidTransformFeedbackBufferCount;
+
+        primary->beginTransformFeedbackEXT(0, numCounterBuffers,
+                                           mTransformFeedbackCounterBuffers.data(), nullptr);
+        mCommandBuffer.executeCommands(primary->getHandle());
+        primary->endTransformFeedbackEXT(0, mValidTransformFeedbackBufferCount,
+                                         mTransformFeedbackCounterBuffers.data(), nullptr);
+
+        primary->endRenderPass();
+
+        // Would be better to accumulate this barrier using the command APIs.
+        // TODO: Clean thus up before we close http://anglebug.com/3206
+        VkBufferMemoryBarrier bufferBarrier = {};
+        bufferBarrier.sType                 = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
+        bufferBarrier.pNext                 = nullptr;
+        bufferBarrier.srcAccessMask         = VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT;
+        bufferBarrier.dstAccessMask         = VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT;
+        bufferBarrier.srcQueueFamilyIndex   = VK_QUEUE_FAMILY_IGNORED;
+        bufferBarrier.dstQueueFamilyIndex   = VK_QUEUE_FAMILY_IGNORED;
+        bufferBarrier.buffer                = mTransformFeedbackCounterBuffers[0];
+        bufferBarrier.offset                = 0;
+        bufferBarrier.size                  = VK_WHOLE_SIZE;
+
+        primary->pipelineBarrier(VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT,
+                                 VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT, 0u, 0u, nullptr, 1u,
+                                 &bufferBarrier, 0u, nullptr);
+    }
 
     // Restart the command buffer.
     reset();
@@ -4071,5 +4175,7 @@ void RenderPassCommandBuffer::reset()
 {
     mCommandBuffer.reset();
     mRenderPassStarted                 = false;
+    mValidTransformFeedbackBufferCount = 0;
+    mRebindTransformFeedbackBuffers    = false;
 }
 }  // namespace rx

src/libANGLE/renderer/vulkan/ContextVk.h

@@ -163,6 +163,10 @@ class RenderPassCommandBuffer final : public CommandBufferHelper
                          const std::vector<VkClearValue> &clearValues,
                          vk::CommandBuffer **commandBufferOut);
 
+    void beginTransformFeedback(size_t validBufferCount,
+                                const VkBuffer *counterBuffers,
+                                bool rebindBuffer);
+
     void clearRenderPassColorAttachment(size_t attachmentIndex, const VkClearColorValue &clearValue)
     {
         mAttachmentOps[attachmentIndex].loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
@@ -218,6 +222,11 @@ class RenderPassCommandBuffer final : public CommandBufferHelper
     gl::Rectangle mRenderArea;
     gl::AttachmentArray<VkClearValue> mClearValues;
     bool mRenderPassStarted;
+
+    // Transform feedback state
+    gl::TransformFeedbackBuffersArray<VkBuffer> mTransformFeedbackCounterBuffers;
+    uint32_t mValidTransformFeedbackBufferCount;
+    bool mRebindTransformFeedbackBuffers;
 };
 
 class ContextVk : public ContextImpl, public vk::Context, public vk::RenderPassOwner

src/libANGLE/renderer/vulkan/FramebufferVk.cpp

@@ -525,18 +525,30 @@ angle::Result FramebufferVk::blitWithCommand(ContextVk *contextVk,
         blitAspectMask &= ~VK_IMAGE_ASPECT_STENCIL_BIT;
     }
 
+    vk::CommandBuffer *commandBuffer = nullptr;
+    if (contextVk->commandGraphEnabled())
+    {
         if (srcImage->isLayoutChangeNecessary(vk::ImageLayout::TransferSrc))
         {
             vk::CommandBuffer *srcLayoutChange;
             ANGLE_TRY(srcImage->recordCommands(contextVk, &srcLayoutChange));
             srcImage->changeLayout(imageAspectMask, vk::ImageLayout::TransferSrc, srcLayoutChange);
         }
-
-    vk::CommandBuffer *commandBuffer = nullptr;
         ANGLE_TRY(mFramebuffer.recordCommands(contextVk, &commandBuffer));
 
         srcImage->addReadDependency(contextVk, &mFramebuffer);
 
+        // Requirement of the copyImageToBuffer, the dst image must be in
+        // VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL layout.
+        dstImage->changeLayout(imageAspectMask, vk::ImageLayout::TransferDst, commandBuffer);
+    }
+    else
+    {
+        ANGLE_TRY(contextVk->onImageRead(imageAspectMask, vk::ImageLayout::TransferSrc, srcImage));
+        ANGLE_TRY(contextVk->onImageWrite(imageAspectMask, vk::ImageLayout::TransferDst, dstImage));
+        ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer(&commandBuffer));
+    }
+
     VkImageBlit blit                   = {};
     blit.srcSubresource.aspectMask     = blitAspectMask;
     blit.srcSubresource.mipLevel       = readRenderTarget->getLevelIndex();
@@ -551,10 +563,6 @@ angle::Result FramebufferVk::blitWithCommand(ContextVk *contextVk,
     blit.dstOffsets[0]                 = {destArea.x0(), destArea.y0(), 0};
     blit.dstOffsets[1]                 = {destArea.x1(), destArea.y1(), 1};
 
-    // Requirement of the copyImageToBuffer, the dst image must be in
-    // VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL layout.
-    dstImage->changeLayout(imageAspectMask, vk::ImageLayout::TransferDst, commandBuffer);
-
     commandBuffer->blitImage(srcImage->getImage(), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
                              dstImage->getImage(), VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, 1, &blit,
                              gl_vk::GetFilter(filter));

src/libANGLE/renderer/vulkan/ProgramVk.cpp

@@ -1324,6 +1324,8 @@ void ProgramVk::updateDefaultUniformsDescriptorSet(ContextVk *contextVk)
 }
 
 void ProgramVk::updateBuffersDescriptorSet(ContextVk *contextVk,
+                                           vk::ResourceUseList *resourceUseList,
+                                           RenderPassCommandBuffer *renderPassCommands,
                                            vk::CommandGraphResource *recorder,
                                            const std::vector<gl::InterfaceBlock> &blocks,
                                            VkDescriptorType descriptorType)
@@ -1400,6 +1402,20 @@ void ProgramVk::updateBuffersDescriptorSet(ContextVk *contextVk,
                 bufferHelper.onRead(contextVk, recorder, VK_ACCESS_UNIFORM_READ_BIT);
             }
         }
+        else
+        {
+            if (isStorageBuffer)
+            {
+                // We set the SHADER_READ_BIT to be conservative.
+                VkAccessFlags accessFlags = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
+                renderPassCommands->bufferWrite(resourceUseList, accessFlags, &bufferHelper);
+            }
+            else
+            {
+                renderPassCommands->bufferRead(resourceUseList, VK_ACCESS_UNIFORM_READ_BIT,
+                                               &bufferHelper);
+            }
+        }
 
         ++writeCount;
     }
@@ -1457,8 +1473,15 @@ void ProgramVk::updateAtomicCounterBuffersDescriptorSet(ContextVk *contextVk,
         vk::BufferHelper &bufferHelper = bufferVk->getBuffer();
 
         // We set SHADER_READ_BIT to be conservative.
+        if (contextVk->commandGraphEnabled())
+        {
             bufferHelper.onWrite(contextVk, recorder,
                                  VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT);
+        }
+        else
+        {
+            UNIMPLEMENTED();
+        }
 
         writtenBindings.set(binding);
     }
@@ -1567,15 +1590,18 @@ angle::Result ProgramVk::updateImagesDescriptorSet(ContextVk *contextVk,
     return angle::Result::Continue;
 }
 
-angle::Result ProgramVk::updateShaderResourcesDescriptorSet(ContextVk *contextVk,
+angle::Result ProgramVk::updateShaderResourcesDescriptorSet(
+    ContextVk *contextVk,
+    vk::ResourceUseList *resourceUseList,
+    RenderPassCommandBuffer *renderPassCommands,
     vk::CommandGraphResource *recorder)
 {
     ANGLE_TRY(allocateDescriptorSet(contextVk, kShaderResourceDescriptorSetIndex));
 
-    updateBuffersDescriptorSet(contextVk, recorder, mState.getUniformBlocks(),
-                               VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
-    updateBuffersDescriptorSet(contextVk, recorder, mState.getShaderStorageBlocks(),
-                               VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);
+    updateBuffersDescriptorSet(contextVk, resourceUseList, renderPassCommands, recorder,
+                               mState.getUniformBlocks(), VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER);
+    updateBuffersDescriptorSet(contextVk, resourceUseList, renderPassCommands, recorder,
+                               mState.getShaderStorageBlocks(), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER);
     updateAtomicCounterBuffersDescriptorSet(contextVk, recorder);
     return updateImagesDescriptorSet(contextVk, recorder);
 }
@@ -1586,8 +1612,12 @@ angle::Result ProgramVk::updateTransformFeedbackDescriptorSet(ContextVk *context
     const gl::State &glState = contextVk->getState();
     ASSERT(hasTransformFeedbackOutput());
 
-    TransformFeedbackVk *transformFeedbackVk = vk::GetImpl(glState.getCurrentTransformFeedback());
+    if (contextVk->commandGraphEnabled())
+    {
+        TransformFeedbackVk *transformFeedbackVk =
+            vk::GetImpl(glState.getCurrentTransformFeedback());
         transformFeedbackVk->addFramebufferDependency(contextVk, mState, framebuffer);
+    }
 
     ANGLE_TRY(allocateDescriptorSet(contextVk, kUniformsAndXfbDescriptorSetIndex));
 

src/libANGLE/renderer/vulkan/ProgramVk.h

@@ -109,6 +109,8 @@ class ProgramVk : public ProgramImpl
     angle::Result updateUniforms(ContextVk *contextVk);
     angle::Result updateTexturesDescriptorSet(ContextVk *contextVk);
     angle::Result updateShaderResourcesDescriptorSet(ContextVk *contextVk,
+                                                     vk::ResourceUseList *resourceUseList,
+                                                     RenderPassCommandBuffer *renderPassCommands,
                                                      vk::CommandGraphResource *recorder);
     angle::Result updateTransformFeedbackDescriptorSet(ContextVk *contextVk,
                                                        vk::FramebufferHelper *framebuffer);
@@ -188,6 +190,8 @@ class ProgramVk : public ProgramImpl
     void updateDefaultUniformsDescriptorSet(ContextVk *contextVk);
     void updateTransformFeedbackDescriptorSetImpl(ContextVk *contextVk);
     void updateBuffersDescriptorSet(ContextVk *contextVk,
+                                    vk::ResourceUseList *resourceUseList,
+                                    RenderPassCommandBuffer *renderPassCommands,
                                     vk::CommandGraphResource *recorder,
                                     const std::vector<gl::InterfaceBlock> &blocks,
                                     VkDescriptorType descriptorType);

src/libANGLE/renderer/vulkan/QueryVk.cpp

@@ -49,7 +49,14 @@ angle::Result QueryVk::begin(const gl::Context *context)
     if (getType() == gl::QueryType::TransformFeedbackPrimitivesWritten)
     {
         mTransformFeedbackPrimitivesDrawn = 0;
+        if (contextVk->commandGraphEnabled())
+        {
             contextVk->getCommandGraph()->beginTransformFeedbackEmulatedQuery();
+        }
+        else
+        {
+            // We could consider using VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT.
+        }
         return angle::Result::Continue;
     }
 
@@ -94,8 +101,15 @@ angle::Result QueryVk::end(const gl::Context *context)
             mCachedResult += transformFeedback->getPrimitivesDrawn();
         }
         mCachedResultValid = true;
+        if (contextVk->commandGraphEnabled())
+        {
             contextVk->getCommandGraph()->endTransformFeedbackEmulatedQuery();
         }
+        else
+        {
+            // We could consider using VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT.
+        }
+    }
     else if (getType() == gl::QueryType::TimeElapsed)
     {
         ANGLE_TRY(mQueryHelper.writeTimestamp(contextVk));

src/libANGLE/renderer/vulkan/RenderTargetVk.cpp

@@ -179,7 +179,10 @@ vk::ImageHelper *RenderTargetVk::getImageForWrite(ContextVk *contextVk,
                                                   vk::CommandGraphResource *writingResource) const
 {
     ASSERT(mImage && mImage->valid());
+    if (contextVk->commandGraphEnabled())
+    {
         mImage->addWriteDependency(contextVk, writingResource);
+    }
     onImageViewAccess(contextVk);
     return mImage;
 }

src/libANGLE/renderer/vulkan/SyncVk.cpp

@@ -52,8 +52,17 @@ angle::Result SyncHelper::initialize(ContextVk *contextVk)
 
     mEvent = event.release();
 
+    if (contextVk->commandGraphEnabled())
+    {
         CommandGraph *commandGraph = contextVk->getCommandGraph();
         commandGraph->setFenceSync(mEvent);
+    }
+    else
+    {
+        vk::PrimaryCommandBuffer *primary;
+        ANGLE_TRY(contextVk->getPrimaryCommandBuffer(&primary));
+        primary->setEvent(mEvent.getHandle(), VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT);
+    }
     contextVk->getResourceUseList().add(mUse);
 
     return angle::Result::Continue;
@@ -105,8 +114,19 @@ angle::Result SyncHelper::clientWait(Context *context,
 
 angle::Result SyncHelper::serverWait(ContextVk *contextVk)
 {
+    if (contextVk->commandGraphEnabled())
+    {
         CommandGraph *commandGraph = contextVk->getCommandGraph();
         commandGraph->waitFenceSync(mEvent);
+    }
+    else
+    {
+        vk::PrimaryCommandBuffer *primary;
+        ANGLE_TRY(contextVk->getPrimaryCommandBuffer(&primary));
+        primary->waitEvents(1, mEvent.ptr(), VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
+                            VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, nullptr, 0, nullptr, 0,
+                            nullptr);
+    }
     contextVk->getResourceUseList().add(mUse);
     return angle::Result::Continue;
 }

src/libANGLE/renderer/vulkan/TextureVk.cpp

@@ -1071,13 +1071,23 @@ angle::Result TextureVk::copyBufferDataToImage(ContextVk *contextVk,
     ANGLE_TRY(ensureImageInitialized(contextVk, ImageMipLevels::EnabledLevels));
 
     vk::CommandBuffer *commandBuffer = nullptr;
+    if (contextVk->commandGraphEnabled())
+    {
         ANGLE_TRY(mImage->recordCommands(contextVk, &commandBuffer));
-
-    mImage->changeLayout(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::TransferDst, commandBuffer);
+        mImage->changeLayout(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::TransferDst,
+                             commandBuffer);
 
         // Source's layout change should happen before the copy
         // Also updates the serial of the srcBuffer
         srcBuffer->addReadDependency(contextVk, mImage);
+    }
+    else
+    {
+        ANGLE_TRY(contextVk->onBufferRead(VK_ACCESS_TRANSFER_READ_BIT, srcBuffer));
+        ANGLE_TRY(contextVk->onImageWrite(VK_IMAGE_ASPECT_COLOR_BIT, vk::ImageLayout::TransferDst,
+                                          mImage));
+        ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer(&commandBuffer));
+    }
 
     VkBufferImageCopy region               = {};
     region.bufferOffset                    = offset;
@@ -1321,7 +1331,15 @@ angle::Result TextureVk::changeLevels(ContextVk *contextVk,
     if (mImage->valid() && mImage->hasStagedUpdates())
     {
         vk::CommandBuffer *commandBuffer = nullptr;
+
+        if (contextVk->commandGraphEnabled())
+        {
             ANGLE_TRY(mImage->recordCommands(contextVk, &commandBuffer));
+        }
+        else
+        {
+            ANGLE_TRY(contextVk->getOutsideRenderPassCommandBuffer(&commandBuffer));
+        }
         ANGLE_TRY(mImage->flushStagedUpdates(contextVk, getNativeImageLevel(0),
                                              mImage->getLevelCount(), getNativeImageLayer(0),
                                              mImage->getLayerCount(), commandBuffer));
@@ -1371,11 +1389,14 @@ angle::Result TextureVk::changeLevels(ContextVk *contextVk,
         }
     }
 
+    if (contextVk->commandGraphEnabled())
+    {
         // Create a new node for the image and add a global memory barrier for the staging buffers.
         // They are written to and staged to be read from when ensureImageInitialized() is called.
         mImage->finishCurrentCommands(contextVk);
         mImage->addGlobalMemoryBarrier(VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_TRANSFER_READ_BIT,
                                        VK_PIPELINE_STAGE_ALL_COMMANDS_BIT);
+    }
 
     // Inform the front end that we've updated the staging buffer
     onStagingBufferChange();

src/libANGLE/renderer/vulkan/TransformFeedbackVk.cpp

@@ -52,9 +52,7 @@ angle::Result TransformFeedbackVk::begin(const gl::Context *context,
         mRebindTransformFeedbackBuffer = true;
     }
 
-    onTransformFeedbackStateChanged(context);
-
-    return angle::Result::Continue;
+    return onTransformFeedbackStateChanged(contextVk);
 }
 
 angle::Result TransformFeedbackVk::end(const gl::Context *context)
@@ -69,11 +67,10 @@ angle::Result TransformFeedbackVk::end(const gl::Context *context)
         vk::GetImpl(transformFeedbackQuery)->onTransformFeedbackEnd(context);
     }
 
-    vk::GetImpl(context)->onTransformFeedbackStateChanged();
-
-    onTransformFeedbackStateChanged(context);
+    ContextVk *contextVk = vk::GetImpl(context);
+    contextVk->onTransformFeedbackStateChanged();
 
-    return angle::Result::Continue;
+    return onTransformFeedbackStateChanged(contextVk);
 }
 
 angle::Result TransformFeedbackVk::pause(const gl::Context *context)
@@ -86,7 +83,7 @@ angle::Result TransformFeedbackVk::pause(const gl::Context *context)
     {
         // We need to create new commandGraphNode to perform transform feedback pause/resume
         // becasue vkCmdBegin/EndTransformFeedback can be placed once per commandGraphNode.
-        onTransformFeedbackStateChanged(context);
+        ANGLE_TRY(onTransformFeedbackStateChanged(contextVk));
     }
 
     return angle::Result::Continue;
@@ -102,7 +99,7 @@ angle::Result TransformFeedbackVk::resume(const gl::Context *context)
     {
         // We need to create new commandGraphNode to perform transform feedback pause/resume
         // becasue vkCmdBegin/EndTransformFeedback can be placed once per commandGraphNode.
-        onTransformFeedbackStateChanged(context);
+        ANGLE_TRY(onTransformFeedbackStateChanged(contextVk));
     }
 
     return angle::Result::Continue;
@@ -312,7 +309,7 @@ void TransformFeedbackVk::getBufferOffsets(ContextVk *contextVk,
     }
 }
 
-void TransformFeedbackVk::onTransformFeedbackStateChanged(const gl::Context *context)
+angle::Result TransformFeedbackVk::onTransformFeedbackStateChanged(ContextVk *contextVk)
 {
     // Currently, we don't handle resources switching from read-only to writable and back correctly.
     // In the case of transform feedback, the attached buffers can switch between being written by
@@ -322,15 +319,23 @@ void TransformFeedbackVk::onTransformFeedbackStateChanged(const gl::Context *con
     // TODO(syoussefi): detect changes to buffer usage (e.g. as transform feedback output, vertex
     // or index data etc) in the front end and notify the backend.  A new node should be created
     // only on such changes.  http://anglebug.com/3205
-    ContextVk *contextVk               = vk::GetImpl(context);
-    FramebufferVk *framebufferVk       = vk::GetImpl(context->getState().getDrawFramebuffer());
+    FramebufferVk *framebufferVk       = vk::GetImpl(contextVk->getState().getDrawFramebuffer());
     vk::FramebufferHelper *framebuffer = framebufferVk->getFramebuffer();
 
+    if (contextVk->commandGraphEnabled())
+    {
         framebuffer->updateCurrentAccessNodes();
         if (framebuffer->hasStartedRenderPass())
         {
             framebuffer->finishCurrentCommands(contextVk);
         }
+    }
+    else
+    {
+        ANGLE_TRY(contextVk->endRenderPass());
+    }
+
+    return angle::Result::Continue;
 }
 
 void TransformFeedbackVk::writeDescriptorSet(ContextVk *contextVk,

src/libANGLE/renderer/vulkan/TransformFeedbackVk.h

@@ -87,7 +87,7 @@ class TransformFeedbackVk : public TransformFeedbackImpl
     }
 
   private:
-    void onTransformFeedbackStateChanged(const gl::Context *context);
+    angle::Result onTransformFeedbackStateChanged(ContextVk *contextVk);
     void writeDescriptorSet(ContextVk *contextVk,
                             size_t xfbBufferCount,
                             VkDescriptorBufferInfo *pBufferInfo,

src/libANGLE/renderer/vulkan/vk_helpers.cpp

@@ -3798,25 +3798,5 @@ angle::Result ShaderProgramHelper::getComputePipeline(Context *context,
     *pipelineOut = &mComputePipeline;
     return angle::Result::Continue;
 }
-
-void MakeDebugUtilsLabel(GLenum source, const char *marker, VkDebugUtilsLabelEXT *label)
-{
-    static constexpr angle::ColorF kLabelColors[6] = {
-        angle::ColorF(1.0f, 0.5f, 0.5f, 1.0f),  // DEBUG_SOURCE_API
-        angle::ColorF(0.5f, 1.0f, 0.5f, 1.0f),  // DEBUG_SOURCE_WINDOW_SYSTEM
-        angle::ColorF(0.5f, 0.5f, 1.0f, 1.0f),  // DEBUG_SOURCE_SHADER_COMPILER
-        angle::ColorF(0.7f, 0.7f, 0.7f, 1.0f),  // DEBUG_SOURCE_THIRD_PARTY
-        angle::ColorF(0.5f, 0.8f, 0.9f, 1.0f),  // DEBUG_SOURCE_APPLICATION
-        angle::ColorF(0.9f, 0.8f, 0.5f, 1.0f),  // DEBUG_SOURCE_OTHER
-    };
-
-    int colorIndex = source - GL_DEBUG_SOURCE_API;
-    ASSERT(colorIndex >= 0 && static_cast<size_t>(colorIndex) < ArraySize(kLabelColors));
-
-    label->sType      = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
-    label->pNext      = nullptr;
-    label->pLabelName = marker;
-    kLabelColors[colorIndex].writeData(label->color);
-}
 }  // namespace vk
 }  // namespace rx

src/libANGLE/renderer/vulkan/vk_utils.cpp

@@ -546,6 +546,25 @@ void GarbageObject::destroy(VkDevice device)
     }
 }
 
+void MakeDebugUtilsLabel(GLenum source, const char *marker, VkDebugUtilsLabelEXT *label)
+{
+    static constexpr angle::ColorF kLabelColors[6] = {
+        angle::ColorF(1.0f, 0.5f, 0.5f, 1.0f),  // DEBUG_SOURCE_API
+        angle::ColorF(0.5f, 1.0f, 0.5f, 1.0f),  // DEBUG_SOURCE_WINDOW_SYSTEM
+        angle::ColorF(0.5f, 0.5f, 1.0f, 1.0f),  // DEBUG_SOURCE_SHADER_COMPILER
+        angle::ColorF(0.7f, 0.7f, 0.7f, 1.0f),  // DEBUG_SOURCE_THIRD_PARTY
+        angle::ColorF(0.5f, 0.8f, 0.9f, 1.0f),  // DEBUG_SOURCE_APPLICATION
+        angle::ColorF(0.9f, 0.8f, 0.5f, 1.0f),  // DEBUG_SOURCE_OTHER
+    };
+
+    int colorIndex = source - GL_DEBUG_SOURCE_API;
+    ASSERT(colorIndex >= 0 && static_cast<size_t>(colorIndex) < ArraySize(kLabelColors));
+
+    label->sType      = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
+    label->pNext      = nullptr;
+    label->pLabelName = marker;
+    kLabelColors[colorIndex].writeData(label->color);
+}
 }  // namespace vk
 
 namespace gl_vk

src/libANGLE/renderer/vulkan/vk_utils.h

@@ -614,6 +614,7 @@ static_assert(sizeof(SpecializationConstantBitSet) == sizeof(uint32_t), "Unexpec
 template <typename T>
 using SpecializationConstantMap = angle::PackedEnumMap<sh::vk::SpecializationConstantId, T>;
 
+void MakeDebugUtilsLabel(GLenum source, const char *marker, VkDebugUtilsLabelEXT *label);
 }  // namespace vk
 
 namespace gl_vk

src/tests/test_utils/angle_test_instantiate.h

@@ -121,7 +121,8 @@ struct CombinedPrintToStringParamName
         ES2_METAL(), WithNoCommandGraph(ES2_VULKAN())
 
 #define ANGLE_ALL_TEST_PLATFORMS_ES3                                                   \
-    ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES(), ES3_VULKAN(), ES3_VULKAN_SWIFTSHADER()
+    ES3_D3D11(), ES3_OPENGL(), ES3_OPENGLES(), ES3_VULKAN(), ES3_VULKAN_SWIFTSHADER(), \
+        WithNoCommandGraph(ES3_VULKAN())
 
 #define ANGLE_ALL_TEST_PLATFORMS_ES31 \
     ES31_D3D11(), ES31_OPENGL(), ES31_OPENGLES(), ES31_VULKAN(), ES31_VULKAN_SWIFTSHADER()