From 4cf41673ba0a1861d7409f9bfe7c6cc3ff170564 Mon Sep 17 00:00:00 2001 From: MrPurple666 Date: Tue, 29 Apr 2025 22:00:51 -0300 Subject: [PATCH] Fix some issues in RAII --- .../renderer_vulkan/renderer_vulkan.cpp | 10 +- .../renderer_vulkan/renderer_vulkan.h | 6 +- src/video_core/vulkan_common/vulkan_raii.h | 99 +++++++++---------- 3 files changed, 54 insertions(+), 61 deletions(-) diff --git a/src/video_core/renderer_vulkan/renderer_vulkan.cpp b/src/video_core/renderer_vulkan/renderer_vulkan.cpp index cf7ce0cbbc..ebc50290a9 100644 --- a/src/video_core/renderer_vulkan/renderer_vulkan.cpp +++ b/src/video_core/renderer_vulkan/renderer_vulkan.cpp @@ -110,16 +110,16 @@ RendererVulkan::RendererVulkan(Core::Frontend::EmuWindow& emu_window, instance(CreateInstance(*library, dld, VK_API_VERSION_1_1, render_window.GetWindowInfo().type, Settings::values.renderer_debug.GetValue())), // Now create RAII wrappers for the resources in the correct order - raii_instance(MakeInstance(instance, dld)), + managed_instance(MakeManagedInstance(instance, dld)), // Create debug messenger if debug is enabled debug_messenger(Settings::values.renderer_debug ? CreateDebugUtilsCallback(instance) : vk::DebugUtilsMessenger{}), - raii_debug_messenger(Settings::values.renderer_debug - ? MakeDebugUtilsMessenger(debug_messenger, instance, dld) - : RaiiDebugUtilsMessenger{}), + managed_debug_messenger(Settings::values.renderer_debug + ? MakeManagedDebugUtilsMessenger(debug_messenger, instance, dld) + : ManagedDebugUtilsMessenger{}), // Create surface surface(CreateSurface(instance, render_window.GetWindowInfo())), - raii_surface(MakeSurface(surface, instance, dld)), + managed_surface(MakeManagedSurface(surface, instance, dld)), device(CreateDevice(instance, dld, *surface)), memory_allocator(device), state_tracker(), scheduler(device, state_tracker), swapchain(*surface, device, scheduler, render_window.GetFramebufferLayout().width, diff --git a/src/video_core/renderer_vulkan/renderer_vulkan.h b/src/video_core/renderer_vulkan/renderer_vulkan.h index 0333106113..748981cc6f 100644 --- a/src/video_core/renderer_vulkan/renderer_vulkan.h +++ b/src/video_core/renderer_vulkan/renderer_vulkan.h @@ -80,15 +80,15 @@ private: // Keep original handles for compatibility with existing code vk::Instance instance; // RAII wrapper for instance - RaiiInstance raii_instance; + ManagedInstance managed_instance; vk::DebugUtilsMessenger debug_messenger; // RAII wrapper for debug messenger - RaiiDebugUtilsMessenger raii_debug_messenger; + ManagedDebugUtilsMessenger managed_debug_messenger; vk::SurfaceKHR surface; // RAII wrapper for surface - RaiiSurface raii_surface; + ManagedSurface managed_surface; Device device; MemoryAllocator memory_allocator; diff --git a/src/video_core/vulkan_common/vulkan_raii.h b/src/video_core/vulkan_common/vulkan_raii.h index c12b16a463..cf5e268b68 100644 --- a/src/video_core/vulkan_common/vulkan_raii.h +++ b/src/video_core/vulkan_common/vulkan_raii.h @@ -29,7 +29,7 @@ public: // Constructor with handle and deleter VulkanRaii(T handle_, DeleterFunc deleter_, const Dispatch& dispatch_, const char* resource_name = "Vulkan resource") : handle{handle_}, deleter{std::move(deleter_)}, dispatch{dispatch_} { - LOG_WARNING(Render_Vulkan, "RAII wrapper created for {}", resource_name); + LOG_DEBUG(Render_Vulkan, "RAII wrapper created for {}", resource_name); } // Move constructor @@ -52,9 +52,6 @@ public: // Destructor - automatically cleans up the resource ~VulkanRaii() { - if (handle != VK_NULL_HANDLE) { - LOG_WARNING(Render_Vulkan, "RAII wrapper destroying resource"); - } cleanup(); } @@ -74,9 +71,7 @@ public: // Release ownership of the handle without destroying it T release() noexcept { - T result = handle; - handle = VK_NULL_HANDLE; - return result; + return std::exchange(handle, VK_NULL_HANDLE); } // Reset the handle (destroying the current one if it exists) @@ -97,12 +92,10 @@ public: } private: - // Optimized cleanup function that avoids unnecessary checks in release builds + // Optimized cleanup function void cleanup() noexcept { - if (handle != VK_NULL_HANDLE) { - if (deleter) { - deleter(handle, dispatch); - } + if (handle != VK_NULL_HANDLE && deleter) { + deleter(handle, dispatch); handle = VK_NULL_HANDLE; } } @@ -112,127 +105,127 @@ private: Dispatch dispatch; }; -// Common type aliases for Vulkan RAII wrappers -using RaiiInstance = VulkanRaii; -using RaiiDevice = VulkanRaii; -using RaiiSurface = VulkanRaii; -using RaiiSwapchain = VulkanRaii; -using RaiiCommandPool = VulkanRaii; -using RaiiBuffer = VulkanRaii; -using RaiiImage = VulkanRaii; -using RaiiImageView = VulkanRaii; -using RaiiSampler = VulkanRaii; -using RaiiShaderModule = VulkanRaii; -using RaiiPipeline = VulkanRaii; -using RaiiPipelineLayout = VulkanRaii; -using RaiiDescriptorSetLayout = VulkanRaii; -using RaiiDescriptorPool = VulkanRaii; -using RaiiSemaphore = VulkanRaii; -using RaiiFence = VulkanRaii; -using RaiiDebugUtilsMessenger = VulkanRaii; +// Common type aliases for Vulkan RAII wrappers with clearer names +using ManagedInstance = VulkanRaii; +using ManagedDevice = VulkanRaii; +using ManagedSurface = VulkanRaii; +using ManagedSwapchain = VulkanRaii; +using ManagedCommandPool = VulkanRaii; +using ManagedBuffer = VulkanRaii; +using ManagedImage = VulkanRaii; +using ManagedImageView = VulkanRaii; +using ManagedSampler = VulkanRaii; +using ManagedShaderModule = VulkanRaii; +using ManagedPipeline = VulkanRaii; +using ManagedPipelineLayout = VulkanRaii; +using ManagedDescriptorSetLayout = VulkanRaii; +using ManagedDescriptorPool = VulkanRaii; +using ManagedSemaphore = VulkanRaii; +using ManagedFence = VulkanRaii; +using ManagedDebugUtilsMessenger = VulkanRaii; // Helper functions to create RAII wrappers /** * Creates an RAII wrapper for a Vulkan instance */ -inline RaiiInstance MakeInstance(const vk::Instance& instance, const vk::InstanceDispatch& dispatch) { +inline ManagedInstance MakeManagedInstance(const vk::Instance& instance, const vk::InstanceDispatch& dispatch) { auto deleter = [](VkInstance handle, const vk::InstanceDispatch& dld) { dld.vkDestroyInstance(handle, nullptr); }; - return RaiiInstance(*instance, deleter, dispatch, "VkInstance"); + return ManagedInstance(*instance, deleter, dispatch, "VkInstance"); } /** * Creates an RAII wrapper for a Vulkan device */ -inline RaiiDevice MakeDevice(const vk::Device& device, const vk::DeviceDispatch& dispatch) { +inline ManagedDevice MakeManagedDevice(const vk::Device& device, const vk::DeviceDispatch& dispatch) { auto deleter = [](VkDevice handle, const vk::DeviceDispatch& dld) { dld.vkDestroyDevice(handle, nullptr); }; - return RaiiDevice(*device, deleter, dispatch, "VkDevice"); + return ManagedDevice(*device, deleter, dispatch, "VkDevice"); } /** * Creates an RAII wrapper for a Vulkan surface */ -inline RaiiSurface MakeSurface(const vk::SurfaceKHR& surface, const vk::Instance& instance, const vk::InstanceDispatch& dispatch) { +inline ManagedSurface MakeManagedSurface(const vk::SurfaceKHR& surface, const vk::Instance& instance, const vk::InstanceDispatch& dispatch) { auto deleter = [instance_ptr = *instance](VkSurfaceKHR handle, const vk::InstanceDispatch& dld) { dld.vkDestroySurfaceKHR(instance_ptr, handle, nullptr); }; - return RaiiSurface(*surface, deleter, dispatch, "VkSurfaceKHR"); + return ManagedSurface(*surface, deleter, dispatch, "VkSurfaceKHR"); } /** * Creates an RAII wrapper for a Vulkan debug messenger */ -inline RaiiDebugUtilsMessenger MakeDebugUtilsMessenger(const vk::DebugUtilsMessenger& messenger, - const vk::Instance& instance, - const vk::InstanceDispatch& dispatch) { +inline ManagedDebugUtilsMessenger MakeManagedDebugUtilsMessenger(const vk::DebugUtilsMessenger& messenger, + const vk::Instance& instance, + const vk::InstanceDispatch& dispatch) { auto deleter = [instance_ptr = *instance](VkDebugUtilsMessengerEXT handle, const vk::InstanceDispatch& dld) { dld.vkDestroyDebugUtilsMessengerEXT(instance_ptr, handle, nullptr); }; - return RaiiDebugUtilsMessenger(*messenger, deleter, dispatch, "VkDebugUtilsMessengerEXT"); + return ManagedDebugUtilsMessenger(*messenger, deleter, dispatch, "VkDebugUtilsMessengerEXT"); } /** * Creates an RAII wrapper for a Vulkan swapchain */ -inline RaiiSwapchain MakeSwapchain(VkSwapchainKHR swapchain_handle, VkDevice device_handle, const vk::DeviceDispatch& dispatch) { +inline ManagedSwapchain MakeManagedSwapchain(VkSwapchainKHR swapchain_handle, VkDevice device_handle, const vk::DeviceDispatch& dispatch) { auto deleter = [device_handle](VkSwapchainKHR handle, const vk::DeviceDispatch& dld) { dld.vkDestroySwapchainKHR(device_handle, handle, nullptr); }; - return RaiiSwapchain(swapchain_handle, deleter, dispatch); + return ManagedSwapchain(swapchain_handle, deleter, dispatch, "VkSwapchainKHR"); } /** * Creates an RAII wrapper for a Vulkan buffer */ -inline RaiiBuffer MakeBuffer(VkBuffer buffer_handle, VkDevice device_handle, const vk::DeviceDispatch& dispatch) { +inline ManagedBuffer MakeManagedBuffer(VkBuffer buffer_handle, VkDevice device_handle, const vk::DeviceDispatch& dispatch) { auto deleter = [device_handle](VkBuffer handle, const vk::DeviceDispatch& dld) { dld.vkDestroyBuffer(device_handle, handle, nullptr); }; - return RaiiBuffer(buffer_handle, deleter, dispatch); + return ManagedBuffer(buffer_handle, deleter, dispatch, "VkBuffer"); } /** * Creates an RAII wrapper for a Vulkan image */ -inline RaiiImage MakeImage(VkImage image_handle, VkDevice device_handle, const vk::DeviceDispatch& dispatch) { +inline ManagedImage MakeManagedImage(VkImage image_handle, VkDevice device_handle, const vk::DeviceDispatch& dispatch) { auto deleter = [device_handle](VkImage handle, const vk::DeviceDispatch& dld) { dld.vkDestroyImage(device_handle, handle, nullptr); }; - return RaiiImage(image_handle, deleter, dispatch); + return ManagedImage(image_handle, deleter, dispatch, "VkImage"); } /** * Creates an RAII wrapper for a Vulkan image view */ -inline RaiiImageView MakeImageView(VkImageView view_handle, VkDevice device_handle, const vk::DeviceDispatch& dispatch) { +inline ManagedImageView MakeManagedImageView(VkImageView view_handle, VkDevice device_handle, const vk::DeviceDispatch& dispatch) { auto deleter = [device_handle](VkImageView handle, const vk::DeviceDispatch& dld) { dld.vkDestroyImageView(device_handle, handle, nullptr); }; - return RaiiImageView(view_handle, deleter, dispatch); + return ManagedImageView(view_handle, deleter, dispatch, "VkImageView"); } /** * Creates an RAII wrapper for a Vulkan semaphore */ -inline RaiiSemaphore MakeSemaphore(VkSemaphore semaphore_handle, VkDevice device_handle, const vk::DeviceDispatch& dispatch) { +inline ManagedSemaphore MakeManagedSemaphore(VkSemaphore semaphore_handle, VkDevice device_handle, const vk::DeviceDispatch& dispatch) { auto deleter = [device_handle](VkSemaphore handle, const vk::DeviceDispatch& dld) { dld.vkDestroySemaphore(device_handle, handle, nullptr); }; - return RaiiSemaphore(semaphore_handle, deleter, dispatch); + return ManagedSemaphore(semaphore_handle, deleter, dispatch, "VkSemaphore"); } /** * Creates an RAII wrapper for a Vulkan fence */ -inline RaiiFence MakeFence(VkFence fence_handle, VkDevice device_handle, const vk::DeviceDispatch& dispatch) { +inline ManagedFence MakeManagedFence(VkFence fence_handle, VkDevice device_handle, const vk::DeviceDispatch& dispatch) { auto deleter = [device_handle](VkFence handle, const vk::DeviceDispatch& dld) { dld.vkDestroyFence(device_handle, handle, nullptr); }; - return RaiiFence(fence_handle, deleter, dispatch); + return ManagedFence(fence_handle, deleter, dispatch, "VkFence"); } -} // namespace Vulkan +} // namespace Vulkan \ No newline at end of file