Vulkan: Don't finish on swap.

src/libANGLE/renderer/vulkan/RendererVk.cpp

@@ -610,30 +610,26 @@ vk::Error RendererVk::submitAndFinishCommandBuffer(const vk::CommandBuffer &comm
     return vk::NoError();
 }
 
-vk::Error RendererVk::waitThenFinishCommandBuffer(const vk::CommandBuffer &commandBuffer,
-                                                  const vk::Semaphore &waitSemaphore)
+vk::Error RendererVk::submitCommandsWithSync(const vk::CommandBuffer &commandBuffer,
+                                             const vk::Semaphore &waitSemaphore,
+                                             const vk::Semaphore &signalSemaphore)
 {
-    VkCommandBuffer commandBufferHandle = commandBuffer.getHandle();
-    VkSemaphore waitHandle              = waitSemaphore.getHandle();
     VkPipelineStageFlags waitStageMask  = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT;
 
     VkSubmitInfo submitInfo;
     submitInfo.sType                = VK_STRUCTURE_TYPE_SUBMIT_INFO;
     submitInfo.pNext                = nullptr;
     submitInfo.waitSemaphoreCount   = 1;
-    submitInfo.pWaitSemaphores      = &waitHandle;
+    submitInfo.pWaitSemaphores      = waitSemaphore.ptr();
     submitInfo.pWaitDstStageMask    = &waitStageMask;
     submitInfo.commandBufferCount   = 1;
-    submitInfo.pCommandBuffers      = &commandBufferHandle;
-    submitInfo.signalSemaphoreCount = 0;
-    submitInfo.pSignalSemaphores    = nullptr;
+    submitInfo.pCommandBuffers      = commandBuffer.ptr();
+    submitInfo.signalSemaphoreCount = 1;
+    submitInfo.pSignalSemaphores    = signalSemaphore.ptr();
 
     // TODO(jmadill): Investigate how to properly queue command buffer work.
     ANGLE_TRY(submit(submitInfo));
 
-    // Wait indefinitely for the queue to finish.
-    ANGLE_TRY(finish());
-
     return vk::NoError();
 }
 

src/libANGLE/renderer/vulkan/RendererVk.h

@@ -53,8 +53,9 @@ class RendererVk : angle::NonCopyable
     vk::CommandBuffer *getCommandBuffer();
     vk::Error submitCommandBuffer(const vk::CommandBuffer &commandBuffer);
     vk::Error submitAndFinishCommandBuffer(const vk::CommandBuffer &commandBuffer);
-    vk::Error waitThenFinishCommandBuffer(const vk::CommandBuffer &commandBuffer,
-                                          const vk::Semaphore &waitSemaphore);
+    vk::Error submitCommandsWithSync(const vk::CommandBuffer &commandBuffer,
+                                     const vk::Semaphore &waitSemaphore,
+                                     const vk::Semaphore &signalSemaphore);
     vk::Error finish();
 
     const gl::Caps &getNativeCaps() const;

src/libANGLE/renderer/vulkan/SurfaceVk.cpp

@@ -174,7 +174,10 @@ void WindowSurfaceVk::destroy(const DisplayImpl *displayImpl)
     VkDevice device            = rendererVk->getDevice();
     VkInstance instance        = rendererVk->getInstance();
 
-    mPresentCompleteSemaphore.destroy(device);
+    rendererVk->finish();
+
+    mImageAvailableSemaphore.destroy(device);
+    mRenderingCompleteSemaphore.destroy(device);
 
     for (auto &imageView : mSwapchainImageViews)
     {
@@ -404,7 +407,10 @@ vk::Error WindowSurfaceVk::initializeImpl(RendererVk *renderer)
     ANGLE_TRY(commandBuffer->end());
     ANGLE_TRY(renderer->submitAndFinishCommandBuffer(*commandBuffer));
 
-    // Start by getting the next available swapchain image.
+    ANGLE_TRY(mImageAvailableSemaphore.init(device));
+    ANGLE_TRY(mRenderingCompleteSemaphore.init(device));
+
+    // Get the first available swapchain iamge.
     ANGLE_TRY(nextSwapchainImage(renderer));
 
     return vk::NoError();
@@ -433,13 +439,14 @@ vk::Error WindowSurfaceVk::swapImpl(RendererVk *renderer)
                                   VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, currentCB);
     currentCB->end();
 
-    ANGLE_TRY(renderer->waitThenFinishCommandBuffer(*currentCB, mPresentCompleteSemaphore));
+    ANGLE_TRY(renderer->submitCommandsWithSync(*currentCB, mImageAvailableSemaphore,
+                                               mRenderingCompleteSemaphore));
 
     VkPresentInfoKHR presentInfo;
     presentInfo.sType              = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
     presentInfo.pNext              = nullptr;
-    presentInfo.waitSemaphoreCount = 0;
-    presentInfo.pWaitSemaphores    = nullptr;
+    presentInfo.waitSemaphoreCount = 1;
+    presentInfo.pWaitSemaphores    = mRenderingCompleteSemaphore.ptr();
     presentInfo.swapchainCount     = 1;
     presentInfo.pSwapchains        = &mSwapchain;
     presentInfo.pImageIndices      = &mCurrentSwapchainImageIndex;
@@ -457,15 +464,10 @@ vk::Error WindowSurfaceVk::nextSwapchainImage(RendererVk *renderer)
 {
     VkDevice device = renderer->getDevice();
 
-    vk::Semaphore presentComplete;
-    ANGLE_TRY(presentComplete.init(device));
-
     ANGLE_VK_TRY(vkAcquireNextImageKHR(device, mSwapchain, std::numeric_limits<uint64_t>::max(),
-                                       presentComplete.getHandle(), VK_NULL_HANDLE,
+                                       mImageAvailableSemaphore.getHandle(), VK_NULL_HANDLE,
                                        &mCurrentSwapchainImageIndex));
 
-    mPresentCompleteSemaphore.retain(device, std::move(presentComplete));
-
     // Update RenderTarget pointers.
     mRenderTarget.image     = &mSwapchainImages[mCurrentSwapchainImageIndex];
     mRenderTarget.imageView = &mSwapchainImageViews[mCurrentSwapchainImageIndex];

src/libANGLE/renderer/vulkan/SurfaceVk.h

@@ -96,7 +96,8 @@ class WindowSurfaceVk : public SurfaceImpl, public ResourceVk
     VkSwapchainKHR mSwapchain;
 
     RenderTargetVk mRenderTarget;
-    vk::Semaphore mPresentCompleteSemaphore;
+    vk::Semaphore mImageAvailableSemaphore;
+    vk::Semaphore mRenderingCompleteSemaphore;
 
     uint32_t mCurrentSwapchainImageIndex;
     std::vector<vk::Image> mSwapchainImages;

src/libANGLE/renderer/vulkan/renderervk_utils.h

@@ -161,6 +161,8 @@ class WrappedObject : angle::NonCopyable
     HandleT getHandle() const { return mHandle; }
     bool valid() const { return (mHandle != VK_NULL_HANDLE); }
 
+    const HandleT *ptr() const { return &mHandle; }
+
   protected:
     WrappedObject() : mHandle(VK_NULL_HANDLE) {}
     WrappedObject(HandleT handle) : mHandle(handle) {}