Vulkan: Reorganize helper classes.

This renames ResourceVk to vk::CommandGraphResource, which should help
clarify its usage. This also moves LineLoopHandler, ImageHelper, and
the DynamicBuffer and DynamicCommandPool classes into a new vk_helpers
module. This file contains helper classes that manage other resources.

Also this makes DynamicBuffer and DynamicDescriptorPool no longer
inherit from CommandGraphResource. In the future, only Impl objects
will be allowed to be graph resources.

Bug: angleproject:2318
Change-Id: I0fa23da2ac853d90f3c822547a4a314f247cc757
Reviewed-on: https://chromium-review.googlesource.com/985200
Commit-Queue: Jamie Madill <[email protected]>
Reviewed-by: Frank Henigman <[email protected]>

Author: null77

src/libANGLE/renderer/vulkan/BufferVk.h

@@ -12,13 +12,13 @@
 
 #include "libANGLE/Observer.h"
 #include "libANGLE/renderer/BufferImpl.h"
-#include "libANGLE/renderer/vulkan/vk_utils.h"
+#include "libANGLE/renderer/vulkan/vk_helpers.h"
 
 namespace rx
 {
 class RendererVk;
 
-class BufferVk : public BufferImpl, public ResourceVk
+class BufferVk : public BufferImpl, public vk::CommandGraphResource
 {
   public:
     BufferVk(const gl::BufferState &state);

src/libANGLE/renderer/vulkan/CommandGraph.cpp

@@ -51,6 +51,98 @@ Error InitAndBeginCommandBuffer(VkDevice device,
 
 }  // anonymous namespace
 
+// CommandGraphResource implementation.
+CommandGraphResource::CommandGraphResource() : mCurrentWritingNode(nullptr)
+{
+}
+
+CommandGraphResource::~CommandGraphResource()
+{
+}
+
+void CommandGraphResource::updateQueueSerial(Serial queueSerial)
+{
+    ASSERT(queueSerial >= mStoredQueueSerial);
+
+    if (queueSerial > mStoredQueueSerial)
+    {
+        mCurrentWritingNode = nullptr;
+        mCurrentReadingNodes.clear();
+        mStoredQueueSerial = queueSerial;
+    }
+}
+
+Serial CommandGraphResource::getQueueSerial() const
+{
+    return mStoredQueueSerial;
+}
+
+bool CommandGraphResource::hasCurrentWritingNode(Serial currentSerial) const
+{
+    return (mStoredQueueSerial == currentSerial && mCurrentWritingNode != nullptr &&
+            !mCurrentWritingNode->hasChildren());
+}
+
+CommandGraphNode *CommandGraphResource::getCurrentWritingNode(Serial currentSerial)
+{
+    ASSERT(currentSerial == mStoredQueueSerial);
+    return mCurrentWritingNode;
+}
+
+CommandGraphNode *CommandGraphResource::getNewWritingNode(RendererVk *renderer)
+{
+    CommandGraphNode *newCommands = renderer->allocateCommandNode();
+    onWriteResource(newCommands, renderer->getCurrentQueueSerial());
+    return newCommands;
+}
+
+Error CommandGraphResource::beginWriteResource(RendererVk *renderer,
+                                               CommandBuffer **commandBufferOut)
+{
+    CommandGraphNode *commands = getNewWritingNode(renderer);
+
+    VkDevice device = renderer->getDevice();
+    ANGLE_TRY(commands->beginOutsideRenderPassRecording(device, renderer->getCommandPool(),
+                                                        commandBufferOut));
+    return NoError();
+}
+
+void CommandGraphResource::onWriteResource(CommandGraphNode *writingNode, Serial serial)
+{
+    updateQueueSerial(serial);
+
+    // Make sure any open reads and writes finish before we execute 'newCommands'.
+    if (!mCurrentReadingNodes.empty())
+    {
+        CommandGraphNode::SetHappensBeforeDependencies(mCurrentReadingNodes, writingNode);
+        mCurrentReadingNodes.clear();
+    }
+
+    if (mCurrentWritingNode && mCurrentWritingNode != writingNode)
+    {
+        CommandGraphNode::SetHappensBeforeDependency(mCurrentWritingNode, writingNode);
+    }
+
+    mCurrentWritingNode = writingNode;
+}
+
+void CommandGraphResource::onReadResource(CommandGraphNode *readingNode, Serial serial)
+{
+    if (hasCurrentWritingNode(serial))
+    {
+        // Ensure 'readOperation' happens after the current write commands.
+        CommandGraphNode::SetHappensBeforeDependency(getCurrentWritingNode(serial), readingNode);
+        ASSERT(mStoredQueueSerial == serial);
+    }
+    else
+    {
+        updateQueueSerial(serial);
+    }
+
+    // Add the read operation to the list of nodes currently reading this resource.
+    mCurrentReadingNodes.push_back(readingNode);
+}
+
 // CommandGraphNode implementation.
 
 CommandGraphNode::CommandGraphNode() : mHasChildren(false), mVisitedState(VisitedState::Unvisited)
@@ -354,7 +446,7 @@ Error CommandGraph::submitCommands(VkDevice device,
     ANGLE_TRY(primaryCommandBufferOut->end());
 
     // TODO(jmadill): Use pool allocation so we don't need to deallocate command graph.
-    for (vk::CommandGraphNode *node : mNodes)
+    for (CommandGraphNode *node : mNodes)
     {
         delete node;
     }

src/libANGLE/renderer/vulkan/CommandGraph.h

@@ -18,6 +18,46 @@ namespace rx
 namespace vk
 {
 
+// This is a helper class for back-end objects used in Vk command buffers. It records a serial
+// at command recording times indicating an order in the queue. We use Fences to detect when
+// commands finish, and then release any unreferenced and deleted resources based on the stored
+// queue serial in a special 'garbage' queue. Resources also track current read and write
+// dependencies. Only one command buffer node can be writing to the Resource at a time, but many
+// can be reading from it. Together the dependencies will form a command graph at submission time.
+class CommandGraphResource
+{
+  public:
+    CommandGraphResource();
+    virtual ~CommandGraphResource();
+
+    void updateQueueSerial(Serial queueSerial);
+    Serial getQueueSerial() const;
+
+    // Returns true if any tracked read or write nodes match 'currentSerial'.
+    bool hasCurrentWritingNode(Serial currentSerial) const;
+
+    // Returns the active write node, and asserts 'currentSerial' matches the stored serial.
+    CommandGraphNode *getCurrentWritingNode(Serial currentSerial);
+
+    // Allocates a new write node and calls onWriteResource internally.
+    CommandGraphNode *getNewWritingNode(RendererVk *renderer);
+
+    // Allocates a write node via getNewWriteNode and returns a started command buffer.
+    // The started command buffer will render outside of a RenderPass.
+    Error beginWriteResource(RendererVk *renderer, CommandBuffer **commandBufferOut);
+
+    // Sets up dependency relations. 'writingNode' will modify 'this' ResourceVk.
+    void onWriteResource(CommandGraphNode *writingNode, Serial serial);
+
+    // Sets up dependency relations. 'readingNode' will read from 'this' ResourceVk.
+    void onReadResource(CommandGraphNode *readingNode, Serial serial);
+
+  private:
+    Serial mStoredQueueSerial;
+    std::vector<CommandGraphNode *> mCurrentReadingNodes;
+    CommandGraphNode *mCurrentWritingNode;
+};
+
 enum class VisitedState
 {
     Unvisited,
@@ -39,7 +79,7 @@ enum class VisitedState
 // for a directed acyclic CommandGraph. When we need to submit the CommandGraph, say during a
 // SwapBuffers or ReadPixels call, we begin a primary Vulkan CommandBuffer, and walk the
 // CommandGraph, starting at the most senior nodes, recording secondary CommandBuffers inside
-// and outside vk::RenderPasses as necessary, filled with the right load/store operations. Once
+// and outside RenderPasses as necessary, filled with the right load/store operations. Once
 // the primary CommandBuffer has recorded all of the secondary CommandBuffers from all the open
 // CommandGraphNodes, we submit the primary CommandBuffer to the VkQueue on the device.
 

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -19,7 +19,6 @@
 #include "libANGLE/renderer/vulkan/CompilerVk.h"
 #include "libANGLE/renderer/vulkan/ContextVk.h"
 #include "libANGLE/renderer/vulkan/DeviceVk.h"
-#include "libANGLE/renderer/vulkan/DynamicDescriptorPool.h"
 #include "libANGLE/renderer/vulkan/FenceNVVk.h"
 #include "libANGLE/renderer/vulkan/FramebufferVk.h"
 #include "libANGLE/renderer/vulkan/ImageVk.h"
@@ -732,7 +731,7 @@ gl::Error ContextVk::memoryBarrierByRegion(const gl::Context *context, GLbitfiel
     return gl::InternalError();
 }
 
-DynamicDescriptorPool *ContextVk::getDynamicDescriptorPool()
+vk::DynamicDescriptorPool *ContextVk::getDynamicDescriptorPool()
 {
     return &mDynamicDescriptorPool;
 }

src/libANGLE/renderer/vulkan/ContextVk.h

@@ -13,9 +13,7 @@
 #include <vulkan/vulkan.h>
 
 #include "libANGLE/renderer/ContextImpl.h"
-#include "libANGLE/renderer/vulkan/DynamicBuffer.h"
-#include "libANGLE/renderer/vulkan/DynamicDescriptorPool.h"
-#include "libANGLE/renderer/vulkan/vk_cache_utils.h"
+#include "libANGLE/renderer/vulkan/vk_helpers.h"
 
 namespace rx
 {
@@ -156,7 +154,7 @@ class ContextVk : public ContextImpl
 
     void invalidateCurrentPipeline();
 
-    DynamicDescriptorPool *getDynamicDescriptorPool();
+    vk::DynamicDescriptorPool *getDynamicDescriptorPool();
 
     const VkClearValue &getClearColorValue() const;
     const VkClearValue &getClearDepthStencilValue() const;
@@ -179,7 +177,7 @@ class ContextVk : public ContextImpl
 
     // The dynamic descriptor pool is externally sychronized, so cannot be accessed from different
     // threads simultaneously. Hence, we keep it in the ContextVk instead of the RendererVk.
-    DynamicDescriptorPool mDynamicDescriptorPool;
+    vk::DynamicDescriptorPool mDynamicDescriptorPool;
 
     // Triggers adding dependencies to the command graph.
     bool mTexturesDirty;
@@ -189,7 +187,6 @@ class ContextVk : public ContextImpl
     VkClearValue mClearColorValue;
     VkClearValue mClearDepthStencilValue;
 };
-
 }  // namespace rx
 
 #endif  // LIBANGLE_RENDERER_VULKAN_CONTEXTVK_H_