github/duckstation
1
0
Fork 0
mirror of https://github.com/stenzek/duckstation.git synced 2025-06-03 02:00:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

VulkanDevice: Allocate N semaphores for N swap chains

Browse Source
This commit is contained in:
Stenzek 2025-05-23 15:16:36 +10:00
parent cdadda85b5
commit 32b3ade56c
No known key found for this signature in database
3 changed files with 48 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/util/vulkan_device.cpp
View File

@ -1433,11 +1433,11 @@ void VulkanDevice::EndAndSubmitCommandBuffer(VulkanSwapChain* present_swap_chain
if (present_swap_chain)
{
submit_info.pWaitSemaphores = present_swap_chain->GetImageAvailableSemaphorePtr();
submit_info.pWaitSemaphores = present_swap_chain->GetImageAcquireSemaphorePtr();
submit_info.waitSemaphoreCount = 1;
submit_info.pWaitDstStageMask = &wait_bits;
submit_info.pSignalSemaphores = present_swap_chain->GetRenderingFinishedSemaphorePtr();
submit_info.pSignalSemaphores = present_swap_chain->GetPresentSemaphorePtr();
submit_info.signalSemaphoreCount = 1;
}
@ -1460,7 +1460,7 @@ void VulkanDevice::QueuePresent(VulkanSwapChain* present_swap_chain)
const VkPresentInfoKHR present_info = {VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
nullptr,
1,
present_swap_chain->GetRenderingFinishedSemaphorePtr(),
present_swap_chain->GetPresentSemaphorePtr(),
1,
present_swap_chain->GetSwapChainPtr(),
present_swap_chain->GetCurrentImageIndexPtr(),

65
src/util/vulkan_swap_chain.cpp
View File

@ -1,4 +1,4 @@
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-FileCopyrightText: 2019-2025 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: CC-BY-NC-ND-4.0
#include "vulkan_swap_chain.h"
@ -75,7 +75,6 @@ VulkanSwapChain::VulkanSwapChain(const WindowInfo& wi, GPUVSyncMode vsync_mode,
std::optional<bool> exclusive_fullscreen_control)
: GPUSwapChain(wi, vsync_mode, allow_present_throttle), m_exclusive_fullscreen_control(exclusive_fullscreen_control)
{
static_assert(NUM_SEMAPHORES == (VulkanDevice::NUM_COMMAND_BUFFERS + 1));
}
VulkanSwapChain::~VulkanSwapChain()
@ -579,24 +578,31 @@ bool VulkanSwapChain::CreateSwapChainImages(VulkanDevice& dev, Error* error)
res = vkGetSwapchainImagesKHR(vkdev, m_swap_chain, &image_count, images.data());
Assert(res == VK_SUCCESS);
const VkRenderPass render_pass =
dev.GetSwapChainRenderPass(m_window_info.surface_format, VK_ATTACHMENT_LOAD_OP_CLEAR);
if (render_pass == VK_NULL_HANDLE)
VkRenderPass render_pass = VK_NULL_HANDLE;
if (!dev.GetOptionalExtensions().vk_khr_dynamic_rendering)
{
Error::SetStringFmt(error, "Failed to get render pass for format {}",
GPUTexture::GetFormatName(m_window_info.surface_format));
return false;
render_pass = dev.GetSwapChainRenderPass(m_window_info.surface_format, VK_ATTACHMENT_LOAD_OP_CLEAR);
if (render_pass == VK_NULL_HANDLE)
{
Error::SetStringFmt(error, "Failed to get render pass for format {}",
GPUTexture::GetFormatName(m_window_info.surface_format));
return false;
}
}
const VkSemaphoreCreateInfo semaphore_info = {VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, nullptr, 0};
const u32 fb_width = GetPostRotatedWidth();
const u32 fb_height = GetPostRotatedHeight();
m_images.reserve(image_count);
m_current_image = 0;
m_current_image_acquire_semaphore = (NUM_IMAGE_ACQUIRE_SEMAPHORES - 1);
for (u32 i = 0; i < image_count; i++)
{
Image& image = m_images.emplace_back();
image.image = images[i];
image.framebuffer = VK_NULL_HANDLE;
image.present_semaphore = VK_NULL_HANDLE;
const VkImageViewCreateInfo view_info = {
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
@ -630,27 +636,21 @@ bool VulkanSwapChain::CreateSwapChainImages(VulkanDevice& dev, Error* error)
return false;
}
}
}
m_current_semaphore = 0;
for (u32 i = 0; i < NUM_SEMAPHORES; i++)
{
ImageSemaphores& sema = m_semaphores[i];
const VkSemaphoreCreateInfo semaphore_info = {VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, nullptr, 0};
res = vkCreateSemaphore(vkdev, &semaphore_info, nullptr, &sema.available_semaphore);
res = vkCreateSemaphore(vkdev, &semaphore_info, nullptr, &image.present_semaphore);
if (res != VK_SUCCESS)
{
Vulkan::SetErrorObject(error, "vkCreateSemaphore failed: ", res);
return false;
}
}
res = vkCreateSemaphore(vkdev, &semaphore_info, nullptr, &sema.rendering_finished_semaphore);
for (u32 i = 0; i < NUM_IMAGE_ACQUIRE_SEMAPHORES; i++)
{
res = vkCreateSemaphore(vkdev, &semaphore_info, nullptr, &m_image_acquire_semaphores[i]);
if (res != VK_SUCCESS)
{
Vulkan::SetErrorObject(error, "vkCreateSemaphore failed: ", res);
vkDestroySemaphore(vkdev, sema.available_semaphore, nullptr);
sema.available_semaphore = VK_NULL_HANDLE;
return false;
}
}
@ -681,19 +681,22 @@ void VulkanSwapChain::DestroySwapChainImages()
for (const auto& it : m_images)
{
// don't defer view destruction, images are no longer valid
if (it.present_semaphore != VK_NULL_HANDLE)
vkDestroySemaphore(vkdev, it.present_semaphore, nullptr);
if (it.framebuffer != VK_NULL_HANDLE)
vkDestroyFramebuffer(vkdev, it.framebuffer, nullptr);
vkDestroyImageView(vkdev, it.view, nullptr);
}
m_images.clear();
for (const auto& it : m_semaphores)
for (auto& it : m_image_acquire_semaphores)
{
if (it.rendering_finished_semaphore != VK_NULL_HANDLE)
vkDestroySemaphore(vkdev, it.rendering_finished_semaphore, nullptr);
if (it.available_semaphore != VK_NULL_HANDLE)
vkDestroySemaphore(vkdev, it.available_semaphore, nullptr);
if (it != VK_NULL_HANDLE)
{
vkDestroySemaphore(vkdev, it, nullptr);
it = VK_NULL_HANDLE;
}
}
m_semaphores = {};
m_image_acquire_result.reset();
}
@ -724,16 +727,14 @@ VkResult VulkanSwapChain::AcquireNextImage(bool handle_errors)
return VK_ERROR_SURFACE_LOST_KHR;
// Use a different semaphore for each image.
m_current_semaphore = (m_current_semaphore + 1) % static_cast<u32>(m_semaphores.size());
m_current_image_acquire_semaphore = (m_current_image_acquire_semaphore + 1) % NUM_IMAGE_ACQUIRE_SEMAPHORES;
VkResult res =
vkAcquireNextImageKHR(VulkanDevice::GetInstance().GetVulkanDevice(), m_swap_chain, UINT64_MAX,
m_semaphores[m_current_semaphore].available_semaphore, VK_NULL_HANDLE, &m_current_image);
VkResult res = vkAcquireNextImageKHR(VulkanDevice::GetInstance().GetVulkanDevice(), m_swap_chain, UINT64_MAX,
GetImageAcquireSemaphore(), VK_NULL_HANDLE, &m_current_image);
if (res != VK_SUCCESS && HandleAcquireOrPresentError(res, false))
{
res =
vkAcquireNextImageKHR(VulkanDevice::GetInstance().GetVulkanDevice(), m_swap_chain, UINT64_MAX,
m_semaphores[m_current_semaphore].available_semaphore, VK_NULL_HANDLE, &m_current_image);
res = vkAcquireNextImageKHR(VulkanDevice::GetInstance().GetVulkanDevice(), m_swap_chain, UINT64_MAX,
GetImageAcquireSemaphore(), VK_NULL_HANDLE, &m_current_image);
}
if (res != VK_SUCCESS)

32
src/util/vulkan_swap_chain.h
View File

@ -1,4 +1,4 @@
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-FileCopyrightText: 2019-2025 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: CC-BY-NC-ND-4.0
#pragma once
@ -31,21 +31,18 @@ public:
ALWAYS_INLINE VkImage GetCurrentImage() const { return m_images[m_current_image].image; }
ALWAYS_INLINE VkImageView GetCurrentImageView() const { return m_images[m_current_image].view; }
ALWAYS_INLINE VkFramebuffer GetCurrentFramebuffer() const { return m_images[m_current_image].framebuffer; }
ALWAYS_INLINE VkSemaphore GetImageAvailableSemaphore() const
ALWAYS_INLINE VkSemaphore GetImageAcquireSemaphore() const
{
return m_semaphores[m_current_semaphore].available_semaphore;
return m_image_acquire_semaphores[m_current_image_acquire_semaphore];
}
ALWAYS_INLINE const VkSemaphore* GetImageAvailableSemaphorePtr() const
ALWAYS_INLINE const VkSemaphore* GetImageAcquireSemaphorePtr() const
{
return &m_semaphores[m_current_semaphore].available_semaphore;
return &m_image_acquire_semaphores[m_current_image_acquire_semaphore];
}
ALWAYS_INLINE VkSemaphore GetRenderingFinishedSemaphore() const
ALWAYS_INLINE VkSemaphore GetPresentSemaphore() const { return m_images[m_current_image].present_semaphore; }
ALWAYS_INLINE const VkSemaphore* GetPresentSemaphorePtr() const
{
return m_semaphores[m_current_semaphore].rendering_finished_semaphore;
}
ALWAYS_INLINE const VkSemaphore* GetRenderingFinishedSemaphorePtr() const
{
return &m_semaphores[m_current_semaphore].rendering_finished_semaphore;
return &m_images[m_current_image].present_semaphore;
}
bool CreateSurface(VkInstance instance, VkPhysicalDevice physical_device, Error* error);
@ -65,7 +62,7 @@ private:
// We don't actually need +1 semaphores, or, more than one really.
// But, the validation layer gets cranky if we don't fence wait before the next image acquire.
// So, add an additional semaphore to ensure that we're never acquiring before fence waiting.
static constexpr u32 NUM_SEMAPHORES = 4; // Should be command buffers + 1
static constexpr u32 NUM_IMAGE_ACQUIRE_SEMAPHORES = 4; // Should be command buffers + 1
std::optional<VkSurfaceFormatKHR> SelectSurfaceFormat(VkPhysicalDevice physdev, Error* error);
std::optional<VkPresentModeKHR> SelectPresentMode(VkPhysicalDevice physdev, GPUVSyncMode& vsync_mode, Error* error);
@ -83,12 +80,7 @@ private:
VkImage image;
VkImageView view;
VkFramebuffer framebuffer;
};
struct ImageSemaphores
{
VkSemaphore available_semaphore;
VkSemaphore rendering_finished_semaphore;
VkSemaphore present_semaphore;
};
VkSurfaceKHR m_surface = VK_NULL_HANDLE;
@ -101,10 +93,10 @@ private:
VkSwapchainKHR m_swap_chain = VK_NULL_HANDLE;
std::vector<Image> m_images;
std::array<ImageSemaphores, NUM_SEMAPHORES> m_semaphores = {};
std::array<VkSemaphore, NUM_IMAGE_ACQUIRE_SEMAPHORES> m_image_acquire_semaphores = {};
u32 m_current_image = 0;
u32 m_current_semaphore = 0;
u32 m_current_image_acquire_semaphore = 0;
VkPresentModeKHR m_present_mode = VK_PRESENT_MODE_IMMEDIATE_KHR;