Vulkan: Implement a SharedResourceUse pool

When adding a Resource to the ResourceUseList of ContextVk
we constructed a new SharedResourceUse object for tracking
and update of the Resource's Serial. We would then delete
it after releasing the resource. This incurs repeated
memory operation costs.

Instead we now allocate a pool of SharedResourceUse objects
and acquire and release from this pool as needed.

VTune profile of the Manhattan 30 offscreen benchmark
shows the CPU occupancy of bufferRead decrease from an
average of 0.9% -> 0.6% and imageRead decreases from
an average of 0.4% -> 0.3%. The bottleneck for both
these methods is the retain() method that leverages
the new SharedResourceUse pool.

Bug: angleproject:4950
Change-Id: Ib4f67c6f101d4b2de118014546e6cc14ad108703
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2396597
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Reviewed-by: Jamie Madill <jmadill@chromium.org>
Commit-Queue: Mohan Maiya <m.maiya@samsung.com>

Author: Mohan Maiya

src/libANGLE/Context.cpp

@@ -621,12 +621,15 @@ egl::Error Context::onDestroy(const egl::Display *display)
     mState.mFramebufferManager->release(this);
     mState.mMemoryObjectManager->release(this);
     mState.mSemaphoreManager->release(this);
-    mState.mShareGroup->release(this);
 
     mThreadPool.reset();
 
     mImplementation->onDestroy(this);
 
+    // Some ShareGroup implementations contain resource pools that implementation contexts
+    // can leverage thus enforcing an ordering during destroy.
+    mState.mShareGroup->release(this);
+
     mOverlay.destroy(this);
 
     return egl::NoError();

src/libANGLE/renderer/vulkan/BufferVk.cpp

@@ -536,7 +536,7 @@ angle::Result BufferVk::acquireAndUpdate(ContextVk *contextVk,
 
     if (updateRegionBeforeSubData || updateRegionAfterSubData)
     {
-        src->retain(&contextVk->getResourceUseList());
+        src->retain(&contextVk->getResourceUseList(), contextVk->getSharedResourceUsePool());
     }
 
     ANGLE_TRY(acquireBufferHelper(contextVk, size, &mBuffer));

src/libANGLE/renderer/vulkan/ContextVk.cpp

@@ -795,7 +795,7 @@ void ContextVk::onDestroy(const gl::Context *context)
 
     mCommandQueue.destroy(device);
 
-    mResourceUseList.releaseResourceUses();
+    mResourceUseList.releaseResourceUses(getSharedResourceUsePool());
 
     mUtils.destroy(mRenderer);
 
@@ -1143,7 +1143,7 @@ angle::Result ContextVk::setupIndirectDraw(const gl::Context *context,
         mCurrentIndirectBuffer = indirectBuffer;
     }
 
-    mRenderPassCommands->bufferRead(&mResourceUseList, VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
+    mRenderPassCommands->bufferRead(this, VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
                                     vk::PipelineStage::DrawIndirect, indirectBuffer);
 
     ANGLE_TRY(setupDraw(context, mode, firstVertex, vertexCount, instanceCount,
@@ -1416,10 +1416,9 @@ ANGLE_INLINE angle::Result ContextVk::handleDirtyTexturesImpl(
             }
         }
         // Ensure the image is in read-only layout
-        commandBufferHelper->imageRead(&mResourceUseList, image.getAspectFlags(), textureLayout,
-                                       &image);
+        commandBufferHelper->imageRead(this, image.getAspectFlags(), textureLayout, &image);
 
-        textureVk->retainImageViews(&mResourceUseList);
+        textureVk->retainImageViews(this);
     }
 
     if (executable->hasTextures())
@@ -1463,7 +1462,7 @@ angle::Result ContextVk::handleDirtyGraphicsVertexBuffers(const gl::Context *con
         vk::BufferHelper *arrayBuffer = arrayBufferResources[attribIndex];
         if (arrayBuffer)
         {
-            mRenderPassCommands->bufferRead(&mResourceUseList, VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,
+            mRenderPassCommands->bufferRead(this, VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT,
                                             vk::PipelineStage::VertexInput, arrayBuffer);
         }
     }
@@ -1481,8 +1480,8 @@ angle::Result ContextVk::handleDirtyGraphicsIndexBuffer(const gl::Context *conte
                                    mVertexArray->getCurrentElementArrayBufferOffset(),
                                    getVkIndexType(mCurrentDrawElementsType));
 
-    mRenderPassCommands->bufferRead(&mResourceUseList, VK_ACCESS_INDEX_READ_BIT,
-                                    vk::PipelineStage::VertexInput, elementArrayBuffer);
+    mRenderPassCommands->bufferRead(this, VK_ACCESS_INDEX_READ_BIT, vk::PipelineStage::VertexInput,
+                                    elementArrayBuffer);
 
     return angle::Result::Continue;
 }
@@ -1544,7 +1543,7 @@ angle::Result ContextVk::handleDirtyGraphicsTransformFeedbackBuffersEmulation(
         {
             vk::BufferHelper *bufferHelper = bufferHelpers[bufferIndex];
             ASSERT(bufferHelper);
-            mRenderPassCommands->bufferWrite(&mResourceUseList, VK_ACCESS_SHADER_WRITE_BIT,
+            mRenderPassCommands->bufferWrite(this, VK_ACCESS_SHADER_WRITE_BIT,
                                              vk::PipelineStage::VertexShader,
                                              vk::AliasingMode::Disallowed, bufferHelper);
         }
@@ -1583,9 +1582,9 @@ angle::Result ContextVk::handleDirtyGraphicsTransformFeedbackBuffersExtension(
     {
         vk::BufferHelper *bufferHelper = bufferHelpers[bufferIndex];
         ASSERT(bufferHelper);
-        mRenderPassCommands->bufferWrite(
-            &mResourceUseList, VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT,
-            vk::PipelineStage::TransformFeedback, vk::AliasingMode::Disallowed, bufferHelper);
+        mRenderPassCommands->bufferWrite(this, VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT,
+                                         vk::PipelineStage::TransformFeedback,
+                                         vk::AliasingMode::Disallowed, bufferHelper);
     }
 
     const gl::TransformFeedbackBuffersArray<VkBuffer> &bufferHandles =
@@ -2282,7 +2281,7 @@ angle::Result ContextVk::drawArraysIndirect(const gl::Context *context,
 
     if (mVertexArray->getStreamingVertexAttribsMask().any())
     {
-        mRenderPassCommands->bufferRead(&mResourceUseList, VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
+        mRenderPassCommands->bufferRead(this, VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
                                         vk::PipelineStage::DrawIndirect, currentIndirectBuf);
 
         // We have instanced vertex attributes that need to be emulated for Vulkan.
@@ -2336,7 +2335,7 @@ angle::Result ContextVk::drawElementsIndirect(const gl::Context *context,
 
     if (mVertexArray->getStreamingVertexAttribsMask().any())
     {
-        mRenderPassCommands->bufferRead(&mResourceUseList, VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
+        mRenderPassCommands->bufferRead(this, VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
                                         vk::PipelineStage::DrawIndirect, currentIndirectBuf);
 
         // We have instanced vertex attributes that need to be emulated for Vulkan.
@@ -3561,7 +3560,7 @@ angle::Result ContextVk::dispatchComputeIndirect(const gl::Context *context, GLi
 
     gl::Buffer *glBuffer     = getState().getTargetBuffer(gl::BufferBinding::DispatchIndirect);
     vk::BufferHelper &buffer = vk::GetImpl(glBuffer)->getBuffer();
-    mOutsideRenderPassCommands->bufferRead(&mResourceUseList, VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
+    mOutsideRenderPassCommands->bufferRead(this, VK_ACCESS_INDIRECT_COMMAND_READ_BIT,
                                            vk::PipelineStage::DrawIndirect, &buffer);
 
     commandBuffer->dispatchIndirect(buffer.getBuffer(), indirect);
@@ -4100,8 +4099,8 @@ angle::Result ContextVk::updateActiveImages(const gl::Context *context,
         }
         VkImageAspectFlags aspectFlags = image->getAspectFlags();
 
-        commandBufferHelper->imageWrite(&mResourceUseList, aspectFlags, imageLayout,
-                                        vk::AliasingMode::Allowed, image);
+        commandBufferHelper->imageWrite(this, aspectFlags, imageLayout, vk::AliasingMode::Allowed,
+                                        image);
     }
 
     return angle::Result::Continue;
@@ -4176,7 +4175,7 @@ angle::Result ContextVk::flushImpl(const vk::Semaphore *signalSemaphore)
     ANGLE_VK_TRY(this, mPrimaryCommands.end());
 
     Serial serial = getCurrentQueueSerial();
-    mResourceUseList.releaseResourceUsesAndUpdateSerials(serial);
+    mResourceUseList.releaseResourceUsesAndUpdateSerials(serial, getSharedResourceUsePool());
 
     waitForSwapchainImageIfNecessary();
 
@@ -4478,7 +4477,7 @@ angle::Result ContextVk::onBufferRead(VkAccessFlags readAccessType,
         ANGLE_TRY(flushOutsideRenderPassCommands());
     }
 
-    mOutsideRenderPassCommands->bufferRead(&mResourceUseList, readAccessType, readStage, buffer);
+    mOutsideRenderPassCommands->bufferRead(this, readAccessType, readStage, buffer);
 
     return angle::Result::Continue;
 }
@@ -4498,7 +4497,7 @@ angle::Result ContextVk::onBufferWrite(VkAccessFlags writeAccessType,
         ANGLE_TRY(flushOutsideRenderPassCommands());
     }
 
-    mOutsideRenderPassCommands->bufferWrite(&mResourceUseList, writeAccessType, writeStage,
+    mOutsideRenderPassCommands->bufferWrite(this, writeAccessType, writeStage,
                                             vk::AliasingMode::Disallowed, buffer);
 
     return angle::Result::Continue;
@@ -4538,7 +4537,7 @@ angle::Result ContextVk::onImageRead(VkImageAspectFlags aspectFlags,
 
     image->recordReadBarrier(aspectFlags, imageLayout,
                              &mOutsideRenderPassCommands->getCommandBuffer());
-    image->retain(&mResourceUseList);
+    image->retain(&mResourceUseList, getSharedResourceUsePool());
 
     return angle::Result::Continue;
 }
@@ -4554,7 +4553,7 @@ angle::Result ContextVk::onImageWrite(VkImageAspectFlags aspectFlags,
 
     image->recordWriteBarrier(aspectFlags, imageLayout,
                               &mOutsideRenderPassCommands->getCommandBuffer());
-    image->retain(&mResourceUseList);
+    image->retain(&mResourceUseList, getSharedResourceUsePool());
     image->onWrite();
 
     return angle::Result::Continue;

src/libANGLE/renderer/vulkan/ContextVk.h

@@ -16,6 +16,7 @@
 #include "common/vulkan/vk_headers.h"
 #include "libANGLE/renderer/ContextImpl.h"
 #include "libANGLE/renderer/renderer_utils.h"
+#include "libANGLE/renderer/vulkan/DisplayVk.h"
 #include "libANGLE/renderer/vulkan/OverlayVk.h"
 #include "libANGLE/renderer/vulkan/PersistentCommandPool.h"
 #include "libANGLE/renderer/vulkan/RendererVk.h"
@@ -482,6 +483,11 @@ class ContextVk : public ContextImpl, public vk::Context
 
     vk::ResourceUseList &getResourceUseList() { return mResourceUseList; }
 
+    ANGLE_INLINE vk::SharedResourceUsePool *getSharedResourceUsePool()
+    {
+        return mShareGroupVk->getSharedResourceUsePool();
+    }
+
     angle::Result onBufferTransferRead(vk::BufferHelper *buffer)
     {
         return onBufferRead(VK_ACCESS_TRANSFER_READ_BIT, vk::PipelineStage::Transfer, buffer);
@@ -526,16 +532,16 @@ class ContextVk : public ContextImpl, public vk::Context
                                vk::ImageHelper *image)
     {
         ASSERT(mRenderPassCommands->started());
-        mRenderPassCommands->imageRead(&mResourceUseList, aspectFlags, imageLayout, image);
+        mRenderPassCommands->imageRead(this, aspectFlags, imageLayout, image);
     }
 
     void onImageRenderPassWrite(VkImageAspectFlags aspectFlags,
                                 vk::ImageLayout imageLayout,
                                 vk::ImageHelper *image)
     {
         ASSERT(mRenderPassCommands->started());
-        mRenderPassCommands->imageWrite(&mResourceUseList, aspectFlags, imageLayout,
-                                        vk::AliasingMode::Allowed, image);
+        mRenderPassCommands->imageWrite(this, aspectFlags, imageLayout, vk::AliasingMode::Allowed,
+                                        image);
     }
 
     vk::CommandBuffer &getOutsideRenderPassCommandBuffer()

src/libANGLE/renderer/vulkan/DisplayVk.cpp

@@ -22,6 +22,7 @@
 namespace rx
 {
 
+// DisplayVk implementation
 DisplayVk::DisplayVk(const egl::DisplayState &state)
     : DisplayImpl(state),
       vk::Context(new RendererVk()),

src/libANGLE/renderer/vulkan/DisplayVk.h

@@ -12,6 +12,7 @@
 
 #include "common/MemoryBuffer.h"
 #include "libANGLE/renderer/DisplayImpl.h"
+#include "libANGLE/renderer/vulkan/ResourceVk.h"
 #include "libANGLE/renderer/vulkan/vk_utils.h"
 
 namespace rx
@@ -22,6 +23,14 @@ class ShareGroupVk : public ShareGroupImpl
 {
   public:
     ShareGroupVk() {}
+
+    ANGLE_INLINE vk::SharedResourceUsePool *getSharedResourceUsePool()
+    {
+        return &mSharedResourceUsePool;
+    }
+
+  private:
+    vk::SharedResourceUsePool mSharedResourceUsePool;
 };
 
 class DisplayVk : public DisplayImpl, public vk::Context

src/libANGLE/renderer/vulkan/ProgramExecutableVk.cpp

@@ -940,7 +940,7 @@ void ProgramExecutableVk::updateDefaultUniformsDescriptorSet(
     else
     {
         vk::BufferHelper &emptyBuffer = contextVk->getEmptyBuffer();
-        emptyBuffer.retain(&contextVk->getResourceUseList());
+        emptyBuffer.retain(&contextVk->getResourceUseList(), contextVk->getSharedResourceUsePool());
         bufferInfo.buffer = emptyBuffer.getBuffer().getHandle();
     }
 
@@ -1044,13 +1044,13 @@ angle::Result ProgramExecutableVk::updateBuffersDescriptorSet(
         {
             // We set the SHADER_READ_BIT to be conservative.
             VkAccessFlags accessFlags = VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT;
-            commandBufferHelper->bufferWrite(resourceUseList, accessFlags,
+            commandBufferHelper->bufferWrite(contextVk, accessFlags,
                                              kPipelineStageShaderMap[shaderType],
                                              vk::AliasingMode::Allowed, &bufferHelper);
         }
         else
         {
-            commandBufferHelper->bufferRead(resourceUseList, VK_ACCESS_UNIFORM_READ_BIT,
+            commandBufferHelper->bufferRead(contextVk, VK_ACCESS_UNIFORM_READ_BIT,
                                             kPipelineStageShaderMap[shaderType], &bufferHelper);
         }
     }
@@ -1126,7 +1126,7 @@ angle::Result ProgramExecutableVk::updateAtomicCounterBuffersDescriptorSet(
 
         // We set SHADER_READ_BIT to be conservative.
         commandBufferHelper->bufferWrite(
-            resourceUseList, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
+            contextVk, VK_ACCESS_SHADER_READ_BIT | VK_ACCESS_SHADER_WRITE_BIT,
             kPipelineStageShaderMap[shaderType], vk::AliasingMode::Allowed, &bufferHelper);
 
         writtenBindings.set(binding);
@@ -1136,7 +1136,7 @@ angle::Result ProgramExecutableVk::updateAtomicCounterBuffersDescriptorSet(
 
     // Bind the empty buffer to every array slot that's unused.
     vk::BufferHelper &emptyBuffer = contextVk->getEmptyBuffer();
-    emptyBuffer.retain(&contextVk->getResourceUseList());
+    emptyBuffer.retain(&contextVk->getResourceUseList(), contextVk->getSharedResourceUsePool());
     size_t count                        = (~writtenBindings).count();
     VkDescriptorBufferInfo *bufferInfos = contextVk->allocDescriptorBufferInfos(count);
     VkWriteDescriptorSet *writeInfos    = contextVk->allocWriteDescriptorSets(count);

src/libANGLE/renderer/vulkan/RenderTargetVk.cpp

@@ -293,10 +293,11 @@ angle::Result RenderTargetVk::flushStagedUpdates(ContextVk *contextVk,
 
 void RenderTargetVk::retainImageViews(ContextVk *contextVk) const
 {
-    mImageViews->retain(&contextVk->getResourceUseList());
+    mImageViews->retain(&contextVk->getResourceUseList(), contextVk->getSharedResourceUsePool());
     if (mResolveImageViews)
     {
-        mResolveImageViews->retain(&contextVk->getResourceUseList());
+        mResolveImageViews->retain(&contextVk->getResourceUseList(),
+                                   contextVk->getSharedResourceUsePool());
     }
 }
 

src/libANGLE/renderer/vulkan/ResourceVk.cpp

@@ -59,6 +59,33 @@ angle::Result Resource::waitForIdle(ContextVk *contextVk, const char *debugMessa
     return angle::Result::Continue;
 }
 
+// SharedResourceUsePool implementation.
+SharedResourceUsePool::SharedResourceUsePool() {}
+
+SharedResourceUsePool::~SharedResourceUsePool() = default;
+
+void SharedResourceUsePool::ensureCapacity()
+{
+    // Allocate a SharedResourceUse block
+    constexpr size_t kSharedResourceUseBlockSize = 2048;
+    size_t newSize                               = (mSharedResourceUsePool.empty())
+                         ? kSharedResourceUseBlockSize
+                         : mSharedResourceUsePool.back().capacity() * 2;
+    SharedResourceUseBlock sharedResourceUseBlock;
+    sharedResourceUseBlock.resize(newSize);
+
+    // Append it to the SharedResourceUse pool
+    mSharedResourceUsePool.emplace_back(std::move(sharedResourceUseBlock));
+
+    // Add the newly allocated SharedResourceUse to the free list
+    mSharedResourceUseFreeList.reserve(newSize);
+    SharedResourceUseBlock &newSharedResourceUseBlock = mSharedResourceUsePool.back();
+    for (SharedResourceUse &use : newSharedResourceUseBlock)
+    {
+        mSharedResourceUseFreeList.push_back(&use);
+    }
+}
+
 // SharedGarbage implementation.
 SharedGarbage::SharedGarbage() = default;
 
@@ -107,23 +134,25 @@ ResourceUseList::~ResourceUseList()
     ASSERT(mResourceUses.empty());
 }
 
-void ResourceUseList::releaseResourceUses()
+void ResourceUseList::releaseResourceUses(SharedResourceUsePool *sharedResourceUsePool)
 {
-    for (SharedResourceUse &use : mResourceUses)
+    for (SharedResourceUse *use : mResourceUses)
     {
-        use.release();
+        use->release();
+        sharedResourceUsePool->releaseSharedResouceUse(use);
     }
-
     mResourceUses.clear();
 }
 
-void ResourceUseList::releaseResourceUsesAndUpdateSerials(Serial serial)
+void ResourceUseList::releaseResourceUsesAndUpdateSerials(
+    Serial serial,
+    SharedResourceUsePool *sharedResourceUsePool)
 {
-    for (SharedResourceUse &use : mResourceUses)
+    for (SharedResourceUse *use : mResourceUses)
     {
-        use.releaseAndUpdateSerial(serial);
+        use->releaseAndUpdateSerial(serial);
+        sharedResourceUsePool->releaseSharedResouceUse(use);
     }
-
     mResourceUses.clear();
 }
 }  // namespace vk