github/duckstation
1
0
Fork 0
mirror of https://github.com/stenzek/duckstation.git synced 2025-06-06 03:25:36 +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) if (present_swap_chain)
{ {
submit_info.pWaitSemaphores = present_swap_chain->GetImageAvailableSemaphorePtr(); submit_info.pWaitSemaphores = present_swap_chain->GetImageAcquireSemaphorePtr();
submit_info.waitSemaphoreCount = 1; submit_info.waitSemaphoreCount = 1;
submit_info.pWaitDstStageMask = &wait_bits; submit_info.pWaitDstStageMask = &wait_bits;
submit_info.pSignalSemaphores = present_swap_chain->GetRenderingFinishedSemaphorePtr(); submit_info.pSignalSemaphores = present_swap_chain->GetPresentSemaphorePtr();
submit_info.signalSemaphoreCount = 1; 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, const VkPresentInfoKHR present_info = {VK_STRUCTURE_TYPE_PRESENT_INFO_KHR,
nullptr, nullptr,
1, 1,
present_swap_chain->GetRenderingFinishedSemaphorePtr(), present_swap_chain->GetPresentSemaphorePtr(),
1, 1,
present_swap_chain->GetSwapChainPtr(), present_swap_chain->GetSwapChainPtr(),
present_swap_chain->GetCurrentImageIndexPtr(), 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 // SPDX-License-Identifier: CC-BY-NC-ND-4.0
#include "vulkan_swap_chain.h" #include "vulkan_swap_chain.h"
@ -75,7 +75,6 @@ VulkanSwapChain::VulkanSwapChain(const WindowInfo& wi, GPUVSyncMode vsync_mode,
std::optional<bool> exclusive_fullscreen_control) std::optional<bool> exclusive_fullscreen_control)
: GPUSwapChain(wi, vsync_mode, allow_present_throttle), m_exclusive_fullscreen_control(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() VulkanSwapChain::~VulkanSwapChain()
@ -579,24 +578,31 @@ bool VulkanSwapChain::CreateSwapChainImages(VulkanDevice& dev, Error* error)
res = vkGetSwapchainImagesKHR(vkdev, m_swap_chain, &image_count, images.data()); res = vkGetSwapchainImagesKHR(vkdev, m_swap_chain, &image_count, images.data());
Assert(res == VK_SUCCESS); Assert(res == VK_SUCCESS);
const VkRenderPass render_pass = VkRenderPass render_pass = VK_NULL_HANDLE;
dev.GetSwapChainRenderPass(m_window_info.surface_format, VK_ATTACHMENT_LOAD_OP_CLEAR); if (!dev.GetOptionalExtensions().vk_khr_dynamic_rendering)
if (render_pass == VK_NULL_HANDLE)
{ {
Error::SetStringFmt(error, "Failed to get render pass for format {}", render_pass = dev.GetSwapChainRenderPass(m_window_info.surface_format, VK_ATTACHMENT_LOAD_OP_CLEAR);
GPUTexture::GetFormatName(m_window_info.surface_format)); if (render_pass == VK_NULL_HANDLE)
return false; {
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_width = GetPostRotatedWidth();
const u32 fb_height = GetPostRotatedHeight(); const u32 fb_height = GetPostRotatedHeight();
m_images.reserve(image_count); m_images.reserve(image_count);
m_current_image = 0; m_current_image = 0;
m_current_image_acquire_semaphore = (NUM_IMAGE_ACQUIRE_SEMAPHORES - 1);
for (u32 i = 0; i < image_count; i++) for (u32 i = 0; i < image_count; i++)
{ {
Image& image = m_images.emplace_back(); Image& image = m_images.emplace_back();
image.image = images[i]; image.image = images[i];
image.framebuffer = VK_NULL_HANDLE; image.framebuffer = VK_NULL_HANDLE;
image.present_semaphore = VK_NULL_HANDLE;
const VkImageViewCreateInfo view_info = { const VkImageViewCreateInfo view_info = {
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
@ -630,27 +636,21 @@ bool VulkanSwapChain::CreateSwapChainImages(VulkanDevice& dev, Error* error)
return false; return false;
} }
} }
}
m_current_semaphore = 0; res = vkCreateSemaphore(vkdev, &semaphore_info, nullptr, &image.present_semaphore);
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);
if (res != VK_SUCCESS) if (res != VK_SUCCESS)
{ {
Vulkan::SetErrorObject(error, "vkCreateSemaphore failed: ", res); Vulkan::SetErrorObject(error, "vkCreateSemaphore failed: ", res);
return false; 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) if (res != VK_SUCCESS)
{ {
Vulkan::SetErrorObject(error, "vkCreateSemaphore failed: ", res); Vulkan::SetErrorObject(error, "vkCreateSemaphore failed: ", res);
vkDestroySemaphore(vkdev, sema.available_semaphore, nullptr);
sema.available_semaphore = VK_NULL_HANDLE;
return false; return false;
} }
} }
@ -681,19 +681,22 @@ void VulkanSwapChain::DestroySwapChainImages()
for (const auto& it : m_images) for (const auto& it : m_images)
{ {
// don't defer view destruction, images are no longer valid // 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) if (it.framebuffer != VK_NULL_HANDLE)
vkDestroyFramebuffer(vkdev, it.framebuffer, nullptr); vkDestroyFramebuffer(vkdev, it.framebuffer, nullptr);
vkDestroyImageView(vkdev, it.view, nullptr); vkDestroyImageView(vkdev, it.view, nullptr);
} }
m_images.clear(); m_images.clear();
for (const auto& it : m_semaphores)
for (auto& it : m_image_acquire_semaphores)
{ {
if (it.rendering_finished_semaphore != VK_NULL_HANDLE) if (it != VK_NULL_HANDLE)
vkDestroySemaphore(vkdev, it.rendering_finished_semaphore, nullptr); {
if (it.available_semaphore != VK_NULL_HANDLE) vkDestroySemaphore(vkdev, it, nullptr);
vkDestroySemaphore(vkdev, it.available_semaphore, nullptr); it = VK_NULL_HANDLE;
}
} }
m_semaphores = {};
m_image_acquire_result.reset(); m_image_acquire_result.reset();
} }
@ -724,16 +727,14 @@ VkResult VulkanSwapChain::AcquireNextImage(bool handle_errors)
return VK_ERROR_SURFACE_LOST_KHR; return VK_ERROR_SURFACE_LOST_KHR;
// Use a different semaphore for each image. // 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 = VkResult res = vkAcquireNextImageKHR(VulkanDevice::GetInstance().GetVulkanDevice(), m_swap_chain, UINT64_MAX,
vkAcquireNextImageKHR(VulkanDevice::GetInstance().GetVulkanDevice(), m_swap_chain, UINT64_MAX, GetImageAcquireSemaphore(), VK_NULL_HANDLE, &m_current_image);
m_semaphores[m_current_semaphore].available_semaphore, VK_NULL_HANDLE, &m_current_image);
if (res != VK_SUCCESS && HandleAcquireOrPresentError(res, false)) if (res != VK_SUCCESS && HandleAcquireOrPresentError(res, false))
{ {
res = res = vkAcquireNextImageKHR(VulkanDevice::GetInstance().GetVulkanDevice(), m_swap_chain, UINT64_MAX,
vkAcquireNextImageKHR(VulkanDevice::GetInstance().GetVulkanDevice(), m_swap_chain, UINT64_MAX, GetImageAcquireSemaphore(), VK_NULL_HANDLE, &m_current_image);
m_semaphores[m_current_semaphore].available_semaphore, VK_NULL_HANDLE, &m_current_image);
} }
if (res != VK_SUCCESS) 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 // SPDX-License-Identifier: CC-BY-NC-ND-4.0
#pragma once #pragma once
@ -31,21 +31,18 @@ public:
ALWAYS_INLINE VkImage GetCurrentImage() const { return m_images[m_current_image].image; } 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 VkImageView GetCurrentImageView() const { return m_images[m_current_image].view; }
ALWAYS_INLINE VkFramebuffer GetCurrentFramebuffer() const { return m_images[m_current_image].framebuffer; } 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; return &m_images[m_current_image].present_semaphore;
}
ALWAYS_INLINE const VkSemaphore* GetRenderingFinishedSemaphorePtr() const
{
return &m_semaphores[m_current_semaphore].rendering_finished_semaphore;
} }
bool CreateSurface(VkInstance instance, VkPhysicalDevice physical_device, Error* error); 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. // 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. // 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. // 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<VkSurfaceFormatKHR> SelectSurfaceFormat(VkPhysicalDevice physdev, Error* error);
std::optional<VkPresentModeKHR> SelectPresentMode(VkPhysicalDevice physdev, GPUVSyncMode& vsync_mode, Error* error); std::optional<VkPresentModeKHR> SelectPresentMode(VkPhysicalDevice physdev, GPUVSyncMode& vsync_mode, Error* error);
@ -83,12 +80,7 @@ private:
VkImage image; VkImage image;
VkImageView view; VkImageView view;
VkFramebuffer framebuffer; VkFramebuffer framebuffer;
}; VkSemaphore present_semaphore;
struct ImageSemaphores
{
VkSemaphore available_semaphore;
VkSemaphore rendering_finished_semaphore;
}; };
VkSurfaceKHR m_surface = VK_NULL_HANDLE; VkSurfaceKHR m_surface = VK_NULL_HANDLE;
@ -101,10 +93,10 @@ private:
VkSwapchainKHR m_swap_chain = VK_NULL_HANDLE; VkSwapchainKHR m_swap_chain = VK_NULL_HANDLE;
std::vector<Image> m_images; 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_image = 0;
u32 m_current_semaphore = 0; u32 m_current_image_acquire_semaphore = 0;
VkPresentModeKHR m_present_mode = VK_PRESENT_MODE_IMMEDIATE_KHR; VkPresentModeKHR m_present_mode = VK_PRESENT_MODE_IMMEDIATE_KHR;