Vulkan: Store current Serial in RendererVk.

src/libANGLE/renderer/vulkan/CommandGraph.cpp

@@ -252,7 +252,7 @@ CommandGraphResource::~CommandGraphResource()
 
 bool CommandGraphResource::isResourceInUse(ContextVk *contextVk) const
 {
-    return mUse.getCounter() > 1 || contextVk->isSerialInUse(mUse.getSerial());
+    return mUse.isCurrentlyInGraph() || contextVk->isSerialInUse(mUse.getSerial());
 }
 
 angle::Result CommandGraphResource::recordCommands(ContextVk *context,

src/libANGLE/renderer/vulkan/CommandGraph.h

@@ -339,10 +339,12 @@ class SharedResourceUse final : angle::NonCopyable
         return mUse->serial;
     }
 
-    ANGLE_INLINE uint32_t getCounter() const
+    // The base counter value for an live resource is "1". Any value greater than one indicates
+    // the resource is in use by a vk::CommandGraph.
+    ANGLE_INLINE bool isCurrentlyInGraph() const
     {
         ASSERT(valid());
-        return mUse->counter;
+        return mUse->counter > 1;
     }
 
   private:
@@ -583,8 +585,8 @@ ANGLE_INLINE bool CommandGraphResource::hasStartedRenderPass() const
 
 ANGLE_INLINE void CommandGraphResource::onGraphAccess(CommandGraph *commandGraph)
 {
-    // Clear dependencies if this is a new access. The minimum counter value is 1.
-    if (mUse.getCounter() == 1)
+    // Clear dependencies if this is a new access.
+    if (!mUse.isCurrentlyInGraph())
     {
         mCurrentWritingNode = nullptr;
         mCurrentReadingNodes.clear();

src/libANGLE/renderer/vulkan/ContextVk.h

@@ -262,16 +262,16 @@ class ContextVk : public ContextImpl, public vk::Context, public vk::RenderPassO
 
     const vk::CommandPool &getCommandPool() const;
 
-    Serial getCurrentQueueSerial() const { return mCurrentQueueSerial; }
-    Serial getLastSubmittedQueueSerial() const { return mLastSubmittedQueueSerial; }
-    Serial getLastCompletedQueueSerial() const { return mLastCompletedQueueSerial; }
+    Serial getCurrentQueueSerial() const { return mRenderer->getCurrentQueueSerial(); }
+    Serial getLastSubmittedQueueSerial() const { return mRenderer->getLastSubmittedQueueSerial(); }
+    Serial getLastCompletedQueueSerial() const { return mRenderer->getLastCompletedQueueSerial(); }
 
     bool isSerialInUse(Serial serial) const;
 
     template <typename T>
     void addGarbage(T *object)
     {
-        object->dumpResources(mCurrentQueueSerial, &mGarbage);
+        object->dumpResources(&mCurrentGarbage);
     }
 
     // Check to see which batches have finished completion (forward progress for
@@ -498,6 +498,7 @@ class ContextVk : public ContextImpl, public vk::Context, public vk::RenderPassO
     bool shouldUseOldRewriteStructSamplers() const;
 
     uint64_t getMaxFenceWaitTimeNs() const;
+    void clearAllGarbage();
 
     vk::PipelineHelper *mCurrentGraphicsPipeline;
     vk::PipelineAndSerial *mCurrentComputePipeline;
@@ -602,10 +603,6 @@ class ContextVk : public ContextImpl, public vk::Context, public vk::RenderPassO
     // We use a Persistent CommandPool with pre-allocated buffers for primary CommandBuffer
     vk::PersistentCommandPool mPrimaryCommandPool;
 
-    Serial mLastCompletedQueueSerial;
-    Serial mLastSubmittedQueueSerial;
-    Serial mCurrentQueueSerial;
-
     struct CommandBatch final : angle::NonCopyable
     {
         CommandBatch();
@@ -627,7 +624,8 @@ class ContextVk : public ContextImpl, public vk::Context, public vk::RenderPassO
     angle::Result recycleCommandBatch(CommandBatch *batch);
 
     std::vector<CommandBatch> mInFlightCommands;
-    std::vector<vk::GarbageObject> mGarbage;
+    vk::GarbageList mCurrentGarbage;
+    vk::GarbageQueue mGarbageQueue;
 
     RenderPassCache mRenderPassCache;
 

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -548,6 +548,8 @@ RendererVk::RendererVk()
       mCurrentQueueFamilyIndex(std::numeric_limits<uint32_t>::max()),
       mMaxVertexAttribDivisor(1),
       mDevice(VK_NULL_HANDLE),
+      mLastCompletedQueueSerial(mQueueSerialFactory.generate()),
+      mCurrentQueueSerial(mQueueSerialFactory.generate()),
       mDeviceLost(false),
       mPipelineCacheVkUpdateTimeout(kPipelineCacheVkUpdatePeriod),
       mPipelineCacheDirty(false),
@@ -606,7 +608,8 @@ void RendererVk::onDestroy(vk::Context *context)
 
 void RendererVk::notifyDeviceLost()
 {
-    mDeviceLost = true;
+    mLastCompletedQueueSerial = mLastSubmittedQueueSerial;
+    mDeviceLost               = true;
     mDisplay->notifyDeviceLost();
 }
 
@@ -1552,7 +1555,8 @@ bool RendererVk::hasBufferFormatFeatureBits(VkFormat format, const VkFormatFeatu
 
 angle::Result RendererVk::queueSubmit(vk::Context *context,
                                       const VkSubmitInfo &submitInfo,
-                                      const vk::Fence &fence)
+                                      const vk::Fence &fence,
+                                      Serial *serialOut)
 {
     {
         std::lock_guard<decltype(mQueueMutex)> lock(mQueueMutex);
@@ -1561,6 +1565,10 @@ angle::Result RendererVk::queueSubmit(vk::Context *context,
 
     ANGLE_TRY(cleanupGarbage(context, false));
 
+    *serialOut                = mCurrentQueueSerial;
+    mLastSubmittedQueueSerial = mCurrentQueueSerial;
+    mCurrentQueueSerial       = mQueueSerialFactory.generate();
+
     return angle::Result::Continue;
 }
 
@@ -1588,11 +1596,6 @@ VkResult RendererVk::queuePresent(const VkPresentInfoKHR &presentInfo)
     }
 }
 
-Serial RendererVk::nextSerial()
-{
-    return mQueueSerialFactory.generate();
-}
-
 angle::Result RendererVk::newSharedFence(vk::Context *context,
                                          vk::Shared<vk::Fence> *sharedFenceOut)
 {
@@ -1716,4 +1719,28 @@ uint64_t RendererVk::getMaxFenceWaitTimeNs() const
 #endif
 }
 
+void RendererVk::onCompletedSerial(Serial serial)
+{
+    if (serial > mLastCompletedQueueSerial)
+    {
+        mLastCompletedQueueSerial = serial;
+    }
+}
+
+angle::Result RendererVk::globalFinish()
+{
+    for (gl::Context *context : mDisplay->getContextSet())
+    {
+        ContextVk *contextVk = vk::GetImpl(context);
+        ANGLE_TRY(contextVk->flushImpl(nullptr));
+    }
+
+    for (gl::Context *context : mDisplay->getContextSet())
+    {
+        ContextVk *contextVk = vk::GetImpl(context);
+        ANGLE_TRY(contextVk->finishImpl());
+    }
+
+    return angle::Result::Continue;
+}
 }  // namespace rx

src/libANGLE/renderer/vulkan/RendererVk.h

@@ -139,12 +139,11 @@ class RendererVk : angle::NonCopyable
 
     angle::Result queueSubmit(vk::Context *context,
                               const VkSubmitInfo &submitInfo,
-                              const vk::Fence &fence);
+                              const vk::Fence &fence,
+                              Serial *serialOut);
     angle::Result queueWaitIdle(vk::Context *context);
     VkResult queuePresent(const VkPresentInfoKHR &presentInfo);
 
-    Serial nextSerial();
-
     angle::Result newSharedFence(vk::Context *context, vk::Shared<vk::Fence> *sharedFenceOut);
     inline void resetSharedFence(vk::Shared<vk::Fence> *sharedFenceIn)
     {
@@ -165,6 +164,14 @@ class RendererVk : angle::NonCopyable
     std::string getAndClearLastValidationMessage(uint32_t *countSinceLastClear);
 
     uint64_t getMaxFenceWaitTimeNs() const;
+    Serial getCurrentQueueSerial() const { return mCurrentQueueSerial; }
+    Serial getLastSubmittedQueueSerial() const { return mLastSubmittedQueueSerial; }
+    Serial getLastCompletedQueueSerial() const { return mLastCompletedQueueSerial; }
+
+    void onCompletedSerial(Serial serial);
+
+    // Calls finish on every Context in the active set.
+    angle::Result globalFinish();
 
   private:
     angle::Result initializeDevice(DisplayVk *displayVk, uint32_t queueFamilyIndex);
@@ -212,6 +219,9 @@ class RendererVk : angle::NonCopyable
     VkDevice mDevice;
     AtomicSerialFactory mQueueSerialFactory;
     AtomicSerialFactory mShaderSerialFactory;
+
+    Serial mLastCompletedQueueSerial;
+    Serial mLastSubmittedQueueSerial;
     Serial mCurrentQueueSerial;
 
     bool mDeviceLost;

src/libANGLE/renderer/vulkan/vk_helpers.cpp

@@ -1755,10 +1755,10 @@ VkImageAspectFlags ImageHelper::getAspectFlags() const
     return GetFormatAspectFlags(mFormat->imageFormat());
 }
 
-void ImageHelper::dumpResources(Serial serial, std::vector<GarbageObject> *garbageQueue)
+void ImageHelper::dumpResources(GarbageList *garbageList)
 {
-    mImage.dumpResources(serial, garbageQueue);
-    mDeviceMemory.dumpResources(serial, garbageQueue);
+    mImage.dumpResources(garbageList);
+    mDeviceMemory.dumpResources(garbageList);
 }
 
 VkImageLayout ImageHelper::getCurrentLayout() const

src/libANGLE/renderer/vulkan/vk_helpers.h

@@ -713,7 +713,7 @@ class ImageHelper final : public CommandGraphResource
 
     VkImageAspectFlags getAspectFlags() const;
     void destroy(VkDevice device);
-    void dumpResources(Serial serial, std::vector<GarbageObject> *garbageQueue);
+    void dumpResources(GarbageList *garbageList);
 
     void init2DWeakReference(VkImage handle,
                              const gl::Extents &glExtents,

src/libANGLE/renderer/vulkan/vk_utils.cpp

@@ -351,10 +351,10 @@ angle::Result StagingBuffer::init(Context *context, VkDeviceSize size, StagingUs
     return angle::Result::Continue;
 }
 
-void StagingBuffer::dumpResources(Serial serial, std::vector<vk::GarbageObject> *garbageQueue)
+void StagingBuffer::dumpResources(GarbageList *garbageList)
 {
-    mBuffer.dumpResources(serial, garbageQueue);
-    mDeviceMemory.dumpResources(serial, garbageQueue);
+    mBuffer.dumpResources(garbageList);
+    mDeviceMemory.dumpResources(garbageList);
 }
 
 angle::Result AllocateBufferMemory(vk::Context *context,
@@ -438,6 +438,18 @@ gl::TextureType Get2DTextureType(uint32_t layerCount, GLint samples)
 GarbageObjectBase::GarbageObjectBase() : mHandleType(HandleType::Invalid), mHandle(VK_NULL_HANDLE)
 {}
 
+GarbageObjectBase::GarbageObjectBase(GarbageObjectBase &&other) : GarbageObjectBase()
+{
+    *this = std::move(other);
+}
+
+GarbageObjectBase &GarbageObjectBase::operator=(GarbageObjectBase &&rhs)
+{
+    std::swap(mHandle, rhs.mHandle);
+    std::swap(mHandleType, rhs.mHandleType);
+    return *this;
+}
+
 // GarbageObjectBase implementation
 void GarbageObjectBase::destroy(VkDevice device)
 {
@@ -508,24 +520,6 @@ void GarbageObjectBase::destroy(VkDevice device)
     }
 }
 
-// GarbageObject implementation.
-GarbageObject::GarbageObject() : mSerial() {}
-
-GarbageObject::GarbageObject(const GarbageObject &other) = default;
-
-GarbageObject &GarbageObject::operator=(const GarbageObject &other) = default;
-
-bool GarbageObject::destroyIfComplete(VkDevice device, Serial completedSerial)
-{
-    if (completedSerial >= mSerial)
-    {
-        destroy(device);
-        return true;
-    }
-
-    return false;
-}
-
 bool SamplerNameContainsNonZeroArrayElement(const std::string &name)
 {
     constexpr char kZERO_ELEMENT[] = "[0]";

src/libANGLE/renderer/vulkan/vk_utils.h

@@ -187,6 +187,45 @@ inline OverlayVk *GetImpl(const gl::DummyOverlay *glObject)
     return nullptr;
 }
 
+template <typename ObjT>
+class ObjectAndSerial final : angle::NonCopyable
+{
+  public:
+    ObjectAndSerial() {}
+
+    ObjectAndSerial(ObjT &&object, Serial serial) : mObject(std::move(object)), mSerial(serial) {}
+
+    ObjectAndSerial(ObjectAndSerial &&other)
+        : mObject(std::move(other.mObject)), mSerial(std::move(other.mSerial))
+    {}
+    ObjectAndSerial &operator=(ObjectAndSerial &&other)
+    {
+        mObject = std::move(other.mObject);
+        mSerial = std::move(other.mSerial);
+        return *this;
+    }
+
+    Serial getSerial() const { return mSerial; }
+    void updateSerial(Serial newSerial) { mSerial = newSerial; }
+
+    const ObjT &get() const { return mObject; }
+    ObjT &get() { return mObject; }
+
+    bool valid() const { return mObject.valid(); }
+
+    void destroy(VkDevice device)
+    {
+        mObject.destroy(device);
+        mSerial = Serial();
+    }
+
+  private:
+    ObjT mObject;
+    Serial mSerial;
+};
+
+// Reference to a deleted object. The object is due to be destroyed at some point in the future.
+// |mHandleType| determines the type of the object and which destroy function should be called.
 class GarbageObjectBase
 {
   public:
@@ -196,6 +235,8 @@ class GarbageObjectBase
           mHandle(reinterpret_cast<VkDevice>(object.getHandle()))
     {}
     GarbageObjectBase();
+    GarbageObjectBase(GarbageObjectBase &&other);
+    GarbageObjectBase &operator=(GarbageObjectBase &&rhs);
 
     void destroy(VkDevice device);
 
@@ -204,25 +245,15 @@ class GarbageObjectBase
     VkDevice mHandle;
 };
 
-class GarbageObject final : public GarbageObjectBase
-{
-  public:
-    template <typename ObjectT>
-    GarbageObject(Serial serial, const ObjectT &object) : GarbageObjectBase(object), mSerial(serial)
-    {}
-
-    GarbageObject();
-    GarbageObject(const GarbageObject &other);
-    GarbageObject &operator=(const GarbageObject &other);
+// A list of garbage objects. Has no object lifetime information.
+using GarbageList = std::vector<GarbageObjectBase>;
 
-    bool destroyIfComplete(VkDevice device, Serial completedSerial);
+// A list of garbage objects and the associated serial after which the objects can be destroyed.
+using GarbageAndSerial = ObjectAndSerial<GarbageList>;
 
-  private:
-    // TODO(jmadill): Since many objects will have the same serial, it might be more efficient to
-    // store the serial outside of the garbage object itself. We could index ranges of garbage
-    // objects in the Renderer, using a circular buffer.
-    Serial mSerial;
-};
+// Houses multiple lists of garbage objects. Each sub-list has a different lifetime. They should
+// be sorted such that later-living garbage is ordered later in the list.
+using GarbageQueue = std::vector<GarbageAndSerial>;
 
 class MemoryProperties final : angle::NonCopyable
 {
@@ -256,7 +287,7 @@ class StagingBuffer final : angle::NonCopyable
     const DeviceMemory &getDeviceMemory() const { return mDeviceMemory; }
     size_t getSize() const { return mSize; }
 
-    void dumpResources(Serial serial, std::vector<GarbageObject> *garbageQueue);
+    void dumpResources(GarbageList *garbageList);
 
   private:
     Buffer mBuffer;
@@ -264,43 +295,6 @@ class StagingBuffer final : angle::NonCopyable
     size_t mSize;
 };
 
-template <typename ObjT>
-class ObjectAndSerial final : angle::NonCopyable
-{
-  public:
-    ObjectAndSerial() {}
-
-    ObjectAndSerial(ObjT &&object, Serial serial) : mObject(std::move(object)), mSerial(serial) {}
-
-    ObjectAndSerial(ObjectAndSerial &&other)
-        : mObject(std::move(other.mObject)), mSerial(std::move(other.mSerial))
-    {}
-    ObjectAndSerial &operator=(ObjectAndSerial &&other)
-    {
-        mObject = std::move(other.mObject);
-        mSerial = std::move(other.mSerial);
-        return *this;
-    }
-
-    Serial getSerial() const { return mSerial; }
-    void updateSerial(Serial newSerial) { mSerial = newSerial; }
-
-    const ObjT &get() const { return mObject; }
-    ObjT &get() { return mObject; }
-
-    bool valid() const { return mObject.valid(); }
-
-    void destroy(VkDevice device)
-    {
-        mObject.destroy(device);
-        mSerial = Serial();
-    }
-
-  private:
-    ObjT mObject;
-    Serial mSerial;
-};
-
 angle::Result AllocateBufferMemory(vk::Context *context,
                                    VkMemoryPropertyFlags requestedMemoryPropertyFlags,
                                    VkMemoryPropertyFlags *memoryPropertyFlagsOut,

src/libANGLE/renderer/vulkan/vk_wrapper.h

@@ -30,16 +30,6 @@ class WrappedObject : angle::NonCopyable
     const HandleT *ptr() const { return &mHandle; }
 
     template <typename ResourceOutType>
-    void dumpResources(Serial serial, std::vector<ResourceOutType> *outQueue)
-    {
-        if (valid())
-        {
-            outQueue->emplace_back(serial, *static_cast<DerivedT *>(this));
-            mHandle = VK_NULL_HANDLE;
-        }
-    }
-
-    template <typename ResourceOutType>
     void dumpResources(std::vector<ResourceOutType> *outQueue)
     {
         if (valid())