Vulkan: Store fences instead of serials in SurfaceVK::SwapHistory

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -1726,6 +1726,17 @@ angle::Result RendererVk::getSubmitFence(vk::Context *context,
     return angle::Result::Continue;
 }
 
+vk::Shared<vk::Fence> RendererVk::getLastSubmittedFence() const
+{
+    vk::Shared<vk::Fence> fence;
+    if (!mInFlightCommands.empty())
+    {
+        fence.copy(getDevice(), mInFlightCommands.back().fence);
+    }
+
+    return fence;
+}
+
 angle::Result RendererVk::getTimestamp(vk::Context *context, uint64_t *timestampOut)
 {
     // The intent of this function is to query the timestamp without stalling the GPU.  Currently,

src/libANGLE/renderer/vulkan/RendererVk.h

@@ -163,6 +163,7 @@ class RendererVk : angle::NonCopyable
 
     // Get (or allocate) the fence that will be signaled on next submission.
     angle::Result getSubmitFence(vk::Context *context, vk::Shared<vk::Fence> *sharedFenceOut);
+    vk::Shared<vk::Fence> getLastSubmittedFence() const;
 
     // This should only be called from ResourceVk.
     // TODO(jmadill): Keep in ContextVk to enable threaded rendering.

src/libANGLE/renderer/vulkan/SurfaceVk.cpp

@@ -299,7 +299,7 @@ WindowSurfaceVk::SwapHistory::SwapHistory(SwapHistory &&other)
 
 WindowSurfaceVk::SwapHistory &WindowSurfaceVk::SwapHistory::operator=(SwapHistory &&other)
 {
-    std::swap(serial, other.serial);
+    std::swap(sharedFence, other.sharedFence);
     std::swap(semaphores, other.semaphores);
     std::swap(swapchain, other.swapchain);
     return *this;
@@ -315,6 +315,8 @@ void WindowSurfaceVk::SwapHistory::destroy(VkDevice device)
         swapchain = VK_NULL_HANDLE;
     }
 
+    sharedFence.reset(device);
+
     for (vk::Semaphore &semaphore : semaphores)
     {
         semaphore.destroy(device);
@@ -322,6 +324,16 @@ void WindowSurfaceVk::SwapHistory::destroy(VkDevice device)
     semaphores.clear();
 }
 
+angle::Result WindowSurfaceVk::SwapHistory::waitFence(DisplayVk *displayVk)
+{
+    if (sharedFence.isReferenced())
+    {
+        ANGLE_VK_TRY(displayVk, sharedFence.get().wait(displayVk->getDevice(),
+                                                       std::numeric_limits<uint64_t>::max()));
+    }
+    return angle::Result::Continue;
+}
+
 WindowSurfaceVk::WindowSurfaceVk(const egl::SurfaceState &surfaceState,
                                  EGLNativeWindowType window,
                                  EGLint width,
@@ -710,8 +722,8 @@ angle::Result WindowSurfaceVk::present(DisplayVk *displayVk,
     SwapHistory &swap = mSwapHistory[mCurrentSwapHistoryIndex];
     {
         TRACE_EVENT0("gpu.angle", "WindowSurfaceVk::present: Throttle CPU");
-        ANGLE_TRY(renderer->finishToSerial(displayVk, swap.serial));
-        swap.destroy(renderer->getDevice());
+        ANGLE_TRY(swap.waitFence(displayVk));
+        swap.destroy(displayVk->getDevice());
     }
 
     SwapchainImage &image = mSwapchainImages[mCurrentSwapchainImageIndex];
@@ -776,7 +788,7 @@ angle::Result WindowSurfaceVk::present(DisplayVk *displayVk,
     }
 
     // Update the swap history for this presentation
-    swap.serial     = renderer->getLastSubmittedQueueSerial();
+    swap.sharedFence = renderer->getLastSubmittedFence();
     swap.semaphores = std::move(mFlushSemaphoreChain);
     ++mCurrentSwapHistoryIndex;
     mCurrentSwapHistoryIndex =

src/libANGLE/renderer/vulkan/SurfaceVk.h

@@ -223,7 +223,11 @@ class WindowSurfaceVk : public SurfaceImpl
 
         void destroy(VkDevice device);
 
-        Serial serial;
+        angle::Result waitFence(DisplayVk *displayVk);
+
+        // Fence associated with the last submitted work to render to this swapchain image.
+        vk::Shared<vk::Fence> sharedFence;
+
         std::vector<vk::Semaphore> semaphores;
         VkSwapchainKHR swapchain = VK_NULL_HANDLE;
     };