From b2de662d67215d75a5ffe578a5894ac932ac7bc1 Mon Sep 17 00:00:00 2001 From: squidbus <175574877+squidbus@users.noreply.github.com> Date: Wed, 25 Sep 2024 02:19:38 -0700 Subject: [PATCH] vulkan: Enable VULKAN_HPP_NO_EXCEPTIONS broadly. (#995) * vulkan: Enable VULKAN_HPP_NO_EXCEPTIONS broadly. * vulkan: Use structured bindings for result where possible. --- src/imgui/renderer/imgui_core.cpp | 6 +- src/imgui/renderer/imgui_impl_vulkan.h | 1 - src/video_core/buffer_cache/buffer.cpp | 4 +- .../renderer_vulkan/renderer_vulkan.cpp | 11 ++- src/video_core/renderer_vulkan/vk_common.h | 3 + .../renderer_vulkan/vk_compute_pipeline.cpp | 22 ++++-- .../renderer_vulkan/vk_graphics_pipeline.cpp | 22 ++++-- .../renderer_vulkan/vk_instance.cpp | 76 ++++++++++++------- .../renderer_vulkan/vk_master_semaphore.cpp | 13 +++- .../renderer_vulkan/vk_pipeline_cache.cpp | 5 +- .../renderer_vulkan/vk_platform.cpp | 28 ++++--- src/video_core/renderer_vulkan/vk_platform.h | 6 +- .../renderer_vulkan/vk_rasterizer.cpp | 1 - .../renderer_vulkan/vk_rasterizer.h | 1 - .../renderer_vulkan/vk_resource_pool.cpp | 10 ++- .../renderer_vulkan/vk_scheduler.cpp | 17 +++-- .../renderer_vulkan/vk_shader_util.cpp | 11 +-- .../renderer_vulkan/vk_swapchain.cpp | 54 ++++++++----- src/video_core/texture_cache/image.cpp | 1 - src/video_core/texture_cache/image_view.cpp | 5 +- src/video_core/texture_cache/sampler.cpp | 5 +- src/video_core/texture_cache/tile_manager.cpp | 9 ++- 22 files changed, 205 insertions(+), 106 deletions(-) diff --git a/src/imgui/renderer/imgui_core.cpp b/src/imgui/renderer/imgui_core.cpp index b972d99d0..a3f4c507f 100644 --- a/src/imgui/renderer/imgui_core.cpp +++ b/src/imgui/renderer/imgui_core.cpp @@ -98,7 +98,11 @@ void OnResize() { } void Shutdown(const vk::Device& device) { - device.waitIdle(); + auto result = device.waitIdle(); + if (result != vk::Result::eSuccess) { + LOG_WARNING(ImGui, "Failed to wait for Vulkan device idle on shutdown: {}", + vk::to_string(result)); + } TextureManager::StopWorker(); diff --git a/src/imgui/renderer/imgui_impl_vulkan.h b/src/imgui/renderer/imgui_impl_vulkan.h index ca76fda6d..e325e2a8d 100644 --- a/src/imgui/renderer/imgui_impl_vulkan.h +++ b/src/imgui/renderer/imgui_impl_vulkan.h @@ -5,7 +5,6 @@ #pragma once -#define VULKAN_HPP_NO_EXCEPTIONS #include "common/types.h" #include "video_core/renderer_vulkan/vk_common.h" diff --git a/src/video_core/buffer_cache/buffer.cpp b/src/video_core/buffer_cache/buffer.cpp index 702958034..9fc972248 100644 --- a/src/video_core/buffer_cache/buffer.cpp +++ b/src/video_core/buffer_cache/buffer.cpp @@ -128,7 +128,9 @@ vk::BufferView Buffer::View(u32 offset, u32 size, bool is_written, AmdGpu::DataF .offset = offset, .range = size, }; - const auto view = instance->GetDevice().createBufferView(view_ci); + const auto [view_result, view] = instance->GetDevice().createBufferView(view_ci); + ASSERT_MSG(view_result == vk::Result::eSuccess, "Failed to create buffer view: {}", + vk::to_string(view_result)); scheduler->DeferOperation( [view, device = instance->GetDevice()] { device.destroyBufferView(view); }); return view; diff --git a/src/video_core/renderer_vulkan/renderer_vulkan.cpp b/src/video_core/renderer_vulkan/renderer_vulkan.cpp index d7954bf79..13bd082d0 100644 --- a/src/video_core/renderer_vulkan/renderer_vulkan.cpp +++ b/src/video_core/renderer_vulkan/renderer_vulkan.cpp @@ -82,7 +82,11 @@ RendererVulkan::RendererVulkan(Frontend::WindowSDL& window_, AmdGpu::Liverpool* present_frames.resize(num_images); for (u32 i = 0; i < num_images; i++) { Frame& frame = present_frames[i]; - frame.present_done = device.createFence({.flags = vk::FenceCreateFlagBits::eSignaled}); + auto [fence_result, fence] = + device.createFence({.flags = vk::FenceCreateFlagBits::eSignaled}); + ASSERT_MSG(fence_result == vk::Result::eSuccess, "Failed to create present done fence: {}", + vk::to_string(fence_result)); + frame.present_done = fence; free_queue.push(&frame); } @@ -157,7 +161,10 @@ void RendererVulkan::RecreateFrame(Frame* frame, u32 width, u32 height) { .layerCount = 1, }, }; - frame->image_view = device.createImageView(view_info); + auto [view_result, view] = device.createImageView(view_info); + ASSERT_MSG(view_result == vk::Result::eSuccess, "Failed to create frame image view: {}", + vk::to_string(view_result)); + frame->image_view = view; frame->width = width; frame->height = height; } diff --git a/src/video_core/renderer_vulkan/vk_common.h b/src/video_core/renderer_vulkan/vk_common.h index a2f9cbcaf..e59eb47eb 100644 --- a/src/video_core/renderer_vulkan/vk_common.h +++ b/src/video_core/renderer_vulkan/vk_common.h @@ -14,6 +14,9 @@ #define VULKAN_HPP_NO_CONSTRUCTORS #define VULKAN_HPP_NO_STRUCT_SETTERS #define VULKAN_HPP_HAS_SPACESHIP_OPERATOR +#define VULKAN_HPP_NO_EXCEPTIONS +// Define assert-on-result to nothing to instead return the result for our handling. +#define VULKAN_HPP_ASSERT_ON_RESULT #include #define VMA_STATIC_VULKAN_FUNCTIONS 0 diff --git a/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp b/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp index 3558bf785..cbce85cc1 100644 --- a/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp +++ b/src/video_core/renderer_vulkan/vk_compute_pipeline.cpp @@ -78,7 +78,12 @@ ComputePipeline::ComputePipeline(const Instance& instance_, Scheduler& scheduler .bindingCount = static_cast(bindings.size()), .pBindings = bindings.data(), }; - desc_layout = instance.GetDevice().createDescriptorSetLayoutUnique(desc_layout_ci); + auto [descriptor_set_result, descriptor_set] = + instance.GetDevice().createDescriptorSetLayoutUnique(desc_layout_ci); + ASSERT_MSG(descriptor_set_result == vk::Result::eSuccess, + "Failed to create compute descriptor set layout: {}", + vk::to_string(descriptor_set_result)); + desc_layout = std::move(descriptor_set); const vk::DescriptorSetLayout set_layout = *desc_layout; const vk::PipelineLayoutCreateInfo layout_info = { @@ -87,19 +92,20 @@ ComputePipeline::ComputePipeline(const Instance& instance_, Scheduler& scheduler .pushConstantRangeCount = 1U, .pPushConstantRanges = &push_constants, }; - pipeline_layout = instance.GetDevice().createPipelineLayoutUnique(layout_info); + auto [layout_result, layout] = instance.GetDevice().createPipelineLayoutUnique(layout_info); + ASSERT_MSG(layout_result == vk::Result::eSuccess, + "Failed to create compute pipeline layout: {}", vk::to_string(layout_result)); + pipeline_layout = std::move(layout); const vk::ComputePipelineCreateInfo compute_pipeline_ci = { .stage = shader_ci, .layout = *pipeline_layout, }; - auto result = + auto [pipeline_result, pipe] = instance.GetDevice().createComputePipelineUnique(pipeline_cache, compute_pipeline_ci); - if (result.result == vk::Result::eSuccess) { - pipeline = std::move(result.value); - } else { - UNREACHABLE_MSG("Graphics pipeline creation failed!"); - } + ASSERT_MSG(pipeline_result == vk::Result::eSuccess, "Failed to create compute pipeline: {}", + vk::to_string(pipeline_result)); + pipeline = std::move(pipe); } ComputePipeline::~ComputePipeline() = default; diff --git a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp index 8edf2f50c..3c191c4a1 100644 --- a/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp +++ b/src/video_core/renderer_vulkan/vk_graphics_pipeline.cpp @@ -39,7 +39,10 @@ GraphicsPipeline::GraphicsPipeline(const Instance& instance_, Scheduler& schedul .pushConstantRangeCount = 1, .pPushConstantRanges = &push_constants, }; - pipeline_layout = instance.GetDevice().createPipelineLayoutUnique(layout_info); + auto [layout_result, layout] = instance.GetDevice().createPipelineLayoutUnique(layout_info); + ASSERT_MSG(layout_result == vk::Result::eSuccess, + "Failed to create graphics pipeline layout: {}", vk::to_string(layout_result)); + pipeline_layout = std::move(layout); boost::container::static_vector vertex_bindings; boost::container::static_vector vertex_attributes; @@ -281,12 +284,11 @@ GraphicsPipeline::GraphicsPipeline(const Instance& instance_, Scheduler& schedul .layout = *pipeline_layout, }; - auto result = device.createGraphicsPipelineUnique(pipeline_cache, pipeline_info); - if (result.result == vk::Result::eSuccess) { - pipeline = std::move(result.value); - } else { - UNREACHABLE_MSG("Graphics pipeline creation failed!"); - } + auto [pipeline_result, pipe] = + device.createGraphicsPipelineUnique(pipeline_cache, pipeline_info); + ASSERT_MSG(pipeline_result == vk::Result::eSuccess, "Failed to create graphics pipeline: {}", + vk::to_string(pipeline_result)); + pipeline = std::move(pipe); } GraphicsPipeline::~GraphicsPipeline() = default; @@ -345,7 +347,11 @@ void GraphicsPipeline::BuildDescSetLayout() { .bindingCount = static_cast(bindings.size()), .pBindings = bindings.data(), }; - desc_layout = instance.GetDevice().createDescriptorSetLayoutUnique(desc_layout_ci); + auto [layout_result, layout] = + instance.GetDevice().createDescriptorSetLayoutUnique(desc_layout_ci); + ASSERT_MSG(layout_result == vk::Result::eSuccess, + "Failed to create graphics descriptor set layout: {}", vk::to_string(layout_result)); + desc_layout = std::move(layout); } void GraphicsPipeline::BindResources(const Liverpool::Regs& regs, diff --git a/src/video_core/renderer_vulkan/vk_instance.cpp b/src/video_core/renderer_vulkan/vk_instance.cpp index d919ace2f..76d7aea56 100644 --- a/src/video_core/renderer_vulkan/vk_instance.cpp +++ b/src/video_core/renderer_vulkan/vk_instance.cpp @@ -23,8 +23,20 @@ namespace Vulkan { namespace { +std::vector EnumeratePhysicalDevices(vk::UniqueInstance& instance) { + auto [devices_result, devices] = instance->enumeratePhysicalDevices(); + ASSERT_MSG(devices_result == vk::Result::eSuccess, "Failed to enumerate physical devices: {}", + vk::to_string(devices_result)); + return std::move(devices); +} + std::vector GetSupportedExtensions(vk::PhysicalDevice physical) { - const std::vector extensions = physical.enumerateDeviceExtensionProperties(); + const auto [extensions_result, extensions] = physical.enumerateDeviceExtensionProperties(); + if (extensions_result != vk::Result::eSuccess) { + LOG_ERROR(Render_Vulkan, "Could not query supported extensions: {}", + vk::to_string(extensions_result)); + return {}; + } std::vector supported_extensions; supported_extensions.reserve(extensions.size()); for (const auto& extension : extensions) { @@ -82,13 +94,13 @@ std::string GetReadableVersion(u32 version) { Instance::Instance(bool enable_validation, bool enable_crash_diagnostic) : instance{CreateInstance(Frontend::WindowSystemType::Headless, enable_validation, enable_crash_diagnostic)}, - physical_devices{instance->enumeratePhysicalDevices()} {} + physical_devices{EnumeratePhysicalDevices(instance)} {} Instance::Instance(Frontend::WindowSDL& window, s32 physical_device_index, bool enable_validation /*= false*/, bool enable_crash_diagnostic /*= false*/) : instance{CreateInstance(window.getWindowInfo().type, enable_validation, enable_crash_diagnostic)}, - physical_devices{instance->enumeratePhysicalDevices()} { + physical_devices{EnumeratePhysicalDevices(instance)} { if (enable_validation) { debug_callback = CreateDebugCallback(*instance); } @@ -421,15 +433,12 @@ bool Instance::CreateDevice() { device_chain.unlink(); } - try { - device = physical_device.createDeviceUnique(device_chain.get()); - } catch (vk::ExtensionNotPresentError& err) { - LOG_CRITICAL(Render_Vulkan, "Some required extensions are not available {}", err.what()); - return false; - } catch (vk::FeatureNotPresentError& err) { - LOG_CRITICAL(Render_Vulkan, "Some required features are not available {}", err.what()); + auto [device_result, dev] = physical_device.createDeviceUnique(device_chain.get()); + if (device_result != vk::Result::eSuccess) { + LOG_CRITICAL(Render_Vulkan, "Failed to create device: {}", vk::to_string(device_result)); return false; } + device = std::move(dev); VULKAN_HPP_DEFAULT_DISPATCHER.init(*device); @@ -437,27 +446,33 @@ bool Instance::CreateDevice() { present_queue = device->getQueue(queue_family_index, 0); if (calibrated_timestamps) { - const auto& time_domains = physical_device.getCalibrateableTimeDomainsEXT(); + const auto [time_domains_result, time_domains] = + physical_device.getCalibrateableTimeDomainsEXT(); + if (time_domains_result == vk::Result::eSuccess) { #if _WIN64 - const bool has_host_time_domain = - std::find(time_domains.cbegin(), time_domains.cend(), - vk::TimeDomainEXT::eQueryPerformanceCounter) != time_domains.cend(); + const bool has_host_time_domain = + std::find(time_domains.cbegin(), time_domains.cend(), + vk::TimeDomainEXT::eQueryPerformanceCounter) != time_domains.cend(); #elif __linux__ - const bool has_host_time_domain = - std::find(time_domains.cbegin(), time_domains.cend(), - vk::TimeDomainEXT::eClockMonotonicRaw) != time_domains.cend(); + const bool has_host_time_domain = + std::find(time_domains.cbegin(), time_domains.cend(), + vk::TimeDomainEXT::eClockMonotonicRaw) != time_domains.cend(); #else - // Tracy limitation means only Windows and Linux can use host time domain. - // https://github.com/shadps4-emu/tracy/blob/c6d779d78508514102fbe1b8eb28bda10d95bb2a/public/tracy/TracyVulkan.hpp#L384-L389 - const bool has_host_time_domain = false; + // Tracy limitation means only Windows and Linux can use host time domain. + // https://github.com/shadps4-emu/tracy/blob/c6d779d78508514102fbe1b8eb28bda10d95bb2a/public/tracy/TracyVulkan.hpp#L384-L389 + const bool has_host_time_domain = false; #endif - if (has_host_time_domain) { - static constexpr std::string_view context_name{"vk_rasterizer"}; - profiler_context = - TracyVkContextHostCalibrated(*instance, physical_device, *device, - VULKAN_HPP_DEFAULT_DISPATCHER.vkGetInstanceProcAddr, - VULKAN_HPP_DEFAULT_DISPATCHER.vkGetDeviceProcAddr); - TracyVkContextName(profiler_context, context_name.data(), context_name.size()); + if (has_host_time_domain) { + static constexpr std::string_view context_name{"vk_rasterizer"}; + profiler_context = TracyVkContextHostCalibrated( + *instance, physical_device, *device, + VULKAN_HPP_DEFAULT_DISPATCHER.vkGetInstanceProcAddr, + VULKAN_HPP_DEFAULT_DISPATCHER.vkGetDeviceProcAddr); + TracyVkContextName(profiler_context, context_name.data(), context_name.size()); + } + } else { + LOG_WARNING(Render_Vulkan, "Could not query calibrated time domains for profiling: {}", + vk::to_string(time_domains_result)); } } @@ -513,7 +528,12 @@ void Instance::CollectToolingInfo() { if (!tooling_info) { return; } - const auto tools = physical_device.getToolPropertiesEXT(); + const auto [tools_result, tools] = physical_device.getToolPropertiesEXT(); + if (tools_result != vk::Result::eSuccess) { + LOG_ERROR(Render_Vulkan, "Could not get Vulkan tool properties: {}", + vk::to_string(tools_result)); + return; + } for (const vk::PhysicalDeviceToolProperties& tool : tools) { const std::string_view name = tool.name; LOG_INFO(Render_Vulkan, "Attached debugging tool: {}", name); diff --git a/src/video_core/renderer_vulkan/vk_master_semaphore.cpp b/src/video_core/renderer_vulkan/vk_master_semaphore.cpp index 753f2bbdf..00f63681e 100644 --- a/src/video_core/renderer_vulkan/vk_master_semaphore.cpp +++ b/src/video_core/renderer_vulkan/vk_master_semaphore.cpp @@ -5,6 +5,8 @@ #include "video_core/renderer_vulkan/vk_instance.h" #include "video_core/renderer_vulkan/vk_master_semaphore.h" +#include "common/assert.h" + namespace Vulkan { constexpr u64 WAIT_TIMEOUT = std::numeric_limits::max(); @@ -17,7 +19,11 @@ MasterSemaphore::MasterSemaphore(const Instance& instance_) : instance{instance_ .initialValue = 0, }, }; - semaphore = instance.GetDevice().createSemaphoreUnique(semaphore_chain.get()); + auto [semaphore_result, sem] = + instance.GetDevice().createSemaphoreUnique(semaphore_chain.get()); + ASSERT_MSG(semaphore_result == vk::Result::eSuccess, "Failed to create master semaphore: {}", + vk::to_string(semaphore_result)); + semaphore = std::move(sem); } MasterSemaphore::~MasterSemaphore() = default; @@ -27,7 +33,10 @@ void MasterSemaphore::Refresh() { u64 counter{}; do { this_tick = gpu_tick.load(std::memory_order_acquire); - counter = instance.GetDevice().getSemaphoreCounterValue(*semaphore); + auto [counter_result, cntr] = instance.GetDevice().getSemaphoreCounterValue(*semaphore); + ASSERT_MSG(counter_result == vk::Result::eSuccess, + "Failed to get master semaphore value: {}", vk::to_string(counter_result)); + counter = cntr; if (counter < this_tick) { return; } diff --git a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp index 7a094f66d..4aca00730 100644 --- a/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp +++ b/src/video_core/renderer_vulkan/vk_pipeline_cache.cpp @@ -136,7 +136,10 @@ PipelineCache::PipelineCache(const Instance& instance_, Scheduler& scheduler_, .subgroup_size = instance.SubgroupSize(), .support_explicit_workgroup_layout = true, }; - pipeline_cache = instance.GetDevice().createPipelineCacheUnique({}); + auto [cache_result, cache] = instance.GetDevice().createPipelineCacheUnique({}); + ASSERT_MSG(cache_result == vk::Result::eSuccess, "Failed to create pipeline cache: {}", + vk::to_string(cache_result)); + pipeline_cache = std::move(cache); } PipelineCache::~PipelineCache() = default; diff --git a/src/video_core/renderer_vulkan/vk_platform.cpp b/src/video_core/renderer_vulkan/vk_platform.cpp index 6abd00aaa..0eb7e0759 100644 --- a/src/video_core/renderer_vulkan/vk_platform.cpp +++ b/src/video_core/renderer_vulkan/vk_platform.cpp @@ -134,9 +134,10 @@ vk::SurfaceKHR CreateSurface(vk::Instance instance, const Frontend::WindowSDL& e std::vector GetInstanceExtensions(Frontend::WindowSystemType window_type, bool enable_debug_utils) { - const auto properties = vk::enumerateInstanceExtensionProperties(); - if (properties.empty()) { - LOG_ERROR(Render_Vulkan, "Failed to query extension properties"); + const auto [properties_result, properties] = vk::enumerateInstanceExtensionProperties(); + if (properties_result != vk::Result::eSuccess || properties.empty()) { + LOG_ERROR(Render_Vulkan, "Failed to query extension properties: {}", + vk::to_string(properties_result)); return {}; } @@ -207,10 +208,12 @@ vk::UniqueInstance CreateInstance(Frontend::WindowSystemType window_type, bool e #endif VULKAN_HPP_DEFAULT_DISPATCHER.init(vkGetInstanceProcAddr); - const u32 available_version = VULKAN_HPP_DEFAULT_DISPATCHER.vkEnumerateInstanceVersion - ? vk::enumerateInstanceVersion() - : VK_API_VERSION_1_0; - + const auto [available_version_result, available_version] = + VULKAN_HPP_DEFAULT_DISPATCHER.vkEnumerateInstanceVersion + ? vk::enumerateInstanceVersion() + : vk::ResultValue(vk::Result::eSuccess, VK_API_VERSION_1_0); + ASSERT_MSG(available_version_result == vk::Result::eSuccess, + "Failed to query Vulkan API version: {}", vk::to_string(available_version_result)); ASSERT_MSG(available_version >= TargetVulkanApiVersion, "Vulkan {}.{} is required, but only {}.{} is supported by instance!", VK_VERSION_MAJOR(TargetVulkanApiVersion), VK_VERSION_MINOR(TargetVulkanApiVersion), @@ -341,11 +344,13 @@ vk::UniqueInstance CreateInstance(Frontend::WindowSystemType window_type, bool e }, }; - auto instance = vk::createInstanceUnique(instance_ci_chain.get()); + auto [instance_result, instance] = vk::createInstanceUnique(instance_ci_chain.get()); + ASSERT_MSG(instance_result == vk::Result::eSuccess, "Failed to create instance: {}", + vk::to_string(instance_result)); VULKAN_HPP_DEFAULT_DISPATCHER.init(*instance); - return instance; + return std::move(instance); } vk::UniqueDebugUtilsMessengerEXT CreateDebugCallback(vk::Instance instance) { @@ -359,7 +364,10 @@ vk::UniqueDebugUtilsMessengerEXT CreateDebugCallback(vk::Instance instance) { vk::DebugUtilsMessageTypeFlagBitsEXT::ePerformance, .pfnUserCallback = DebugUtilsCallback, }; - return instance.createDebugUtilsMessengerEXTUnique(msg_ci); + auto [messenger_result, messenger] = instance.createDebugUtilsMessengerEXTUnique(msg_ci); + ASSERT_MSG(messenger_result == vk::Result::eSuccess, "Failed to create debug callback: {}", + vk::to_string(messenger_result)); + return std::move(messenger); } } // namespace Vulkan diff --git a/src/video_core/renderer_vulkan/vk_platform.h b/src/video_core/renderer_vulkan/vk_platform.h index e38bd2fef..6b425b6d8 100644 --- a/src/video_core/renderer_vulkan/vk_platform.h +++ b/src/video_core/renderer_vulkan/vk_platform.h @@ -7,6 +7,7 @@ #include #include +#include "common/logging/log.h" #include "common/types.h" #include "video_core/renderer_vulkan/vk_common.h" @@ -36,7 +37,10 @@ void SetObjectName(vk::Device device, const HandleType& handle, std::string_view .objectHandle = reinterpret_cast(static_cast(handle)), .pObjectName = debug_name.data(), }; - device.setDebugUtilsObjectNameEXT(name_info); + auto result = device.setDebugUtilsObjectNameEXT(name_info); + if (result != vk::Result::eSuccess) { + LOG_DEBUG(Render_Vulkan, "Could not set object debug name: {}", vk::to_string(result)); + } } template diff --git a/src/video_core/renderer_vulkan/vk_rasterizer.cpp b/src/video_core/renderer_vulkan/vk_rasterizer.cpp index eac272726..edd8e00fb 100644 --- a/src/video_core/renderer_vulkan/vk_rasterizer.cpp +++ b/src/video_core/renderer_vulkan/vk_rasterizer.cpp @@ -24,7 +24,6 @@ Rasterizer::Rasterizer(const Instance& instance_, Scheduler& scheduler_, liverpool->BindRasterizer(this); } memory->SetRasterizer(this); - wfi_event = instance.GetDevice().createEventUnique({}); } Rasterizer::~Rasterizer() = default; diff --git a/src/video_core/renderer_vulkan/vk_rasterizer.h b/src/video_core/renderer_vulkan/vk_rasterizer.h index bd05c8faf..82e8fc0c0 100644 --- a/src/video_core/renderer_vulkan/vk_rasterizer.h +++ b/src/video_core/renderer_vulkan/vk_rasterizer.h @@ -67,7 +67,6 @@ private: AmdGpu::Liverpool* liverpool; Core::MemoryManager* memory; PipelineCache pipeline_cache; - vk::UniqueEvent wfi_event; }; } // namespace Vulkan diff --git a/src/video_core/renderer_vulkan/vk_resource_pool.cpp b/src/video_core/renderer_vulkan/vk_resource_pool.cpp index a5ee22c25..25a134528 100644 --- a/src/video_core/renderer_vulkan/vk_resource_pool.cpp +++ b/src/video_core/renderer_vulkan/vk_resource_pool.cpp @@ -69,7 +69,10 @@ CommandPool::CommandPool(const Instance& instance, MasterSemaphore* master_semap .queueFamilyIndex = instance.GetGraphicsQueueFamilyIndex(), }; const vk::Device device = instance.GetDevice(); - cmd_pool = device.createCommandPoolUnique(pool_create_info); + auto [pool_result, pool] = device.createCommandPoolUnique(pool_create_info); + ASSERT_MSG(pool_result == vk::Result::eSuccess, "Failed to create command pool: {}", + vk::to_string(pool_result)); + cmd_pool = std::move(pool); if (instance.HasDebuggingToolAttached()) { SetObjectName(device, *cmd_pool, "CommandPool"); } @@ -182,7 +185,10 @@ void DescriptorHeap::CreateDescriptorPool() { .poolSizeCount = static_cast(pool_sizes.size()), .pPoolSizes = pool_sizes.data(), }; - curr_pool = device.createDescriptorPool(pool_info); + auto [pool_result, pool] = device.createDescriptorPool(pool_info); + ASSERT_MSG(pool_result == vk::Result::eSuccess, "Failed to create descriptor pool: {}", + vk::to_string(pool_result)); + curr_pool = pool; } } // namespace Vulkan diff --git a/src/video_core/renderer_vulkan/vk_scheduler.cpp b/src/video_core/renderer_vulkan/vk_scheduler.cpp index 08b5014ec..2c4e7a3c6 100644 --- a/src/video_core/renderer_vulkan/vk_scheduler.cpp +++ b/src/video_core/renderer_vulkan/vk_scheduler.cpp @@ -89,7 +89,9 @@ void Scheduler::AllocateWorkerCommandBuffers() { }; current_cmdbuf = command_pool.Commit(); - current_cmdbuf.begin(begin_info); + auto begin_result = current_cmdbuf.begin(begin_info); + ASSERT_MSG(begin_result == vk::Result::eSuccess, "Failed to begin command buffer: {}", + vk::to_string(begin_result)); auto* profiler_ctx = instance.GetProfilerContext(); if (profiler_ctx) { @@ -110,7 +112,9 @@ void Scheduler::SubmitExecution(SubmitInfo& info) { } EndRendering(); - current_cmdbuf.end(); + auto end_result = current_cmdbuf.end(); + ASSERT_MSG(end_result == vk::Result::eSuccess, "Failed to end command buffer: {}", + vk::to_string(end_result)); const vk::Semaphore timeline = master_semaphore.Handle(); info.AddSignal(timeline, signal_value); @@ -138,12 +142,9 @@ void Scheduler::SubmitExecution(SubmitInfo& info) { .pSignalSemaphores = info.signal_semas.data(), }; - try { - ImGui::Core::TextureManager::Submit(); - instance.GetGraphicsQueue().submit(submit_info, info.fence); - } catch (vk::DeviceLostError& err) { - UNREACHABLE_MSG("Device lost during submit: {}", err.what()); - } + ImGui::Core::TextureManager::Submit(); + auto submit_result = instance.GetGraphicsQueue().submit(submit_info, info.fence); + ASSERT_MSG(submit_result != vk::Result::eErrorDeviceLost, "Device lost during submit"); master_semaphore.Refresh(); AllocateWorkerCommandBuffers(); diff --git a/src/video_core/renderer_vulkan/vk_shader_util.cpp b/src/video_core/renderer_vulkan/vk_shader_util.cpp index 687760110..f9347d6e6 100644 --- a/src/video_core/renderer_vulkan/vk_shader_util.cpp +++ b/src/video_core/renderer_vulkan/vk_shader_util.cpp @@ -218,13 +218,10 @@ vk::ShaderModule CompileSPV(std::span code, vk::Device device) { .pCode = code.data(), }; - try { - return device.createShaderModule(shader_info); - } catch (vk::SystemError& err) { - UNREACHABLE_MSG("{}", err.what()); - } - - return {}; + auto [module_result, module] = device.createShaderModule(shader_info); + ASSERT_MSG(module_result == vk::Result::eSuccess, "Failed to compile SPIR-V shader: {}", + vk::to_string(module_result)); + return module; } } // namespace Vulkan diff --git a/src/video_core/renderer_vulkan/vk_swapchain.cpp b/src/video_core/renderer_vulkan/vk_swapchain.cpp index dcc19bf3b..142ef4f5c 100644 --- a/src/video_core/renderer_vulkan/vk_swapchain.cpp +++ b/src/video_core/renderer_vulkan/vk_swapchain.cpp @@ -37,8 +37,12 @@ void Swapchain::Create(u32 width_, u32 height_, vk::SurfaceKHR surface_) { instance.GetPresentQueueFamilyIndex(), }; - const auto modes = instance.GetPhysicalDevice().getSurfacePresentModesKHR(surface); - const auto find_mode = [&modes](vk::PresentModeKHR requested) { + const auto [modes_result, modes] = + instance.GetPhysicalDevice().getSurfacePresentModesKHR(surface); + const auto find_mode = [&modes_result, &modes](vk::PresentModeKHR requested) { + if (modes_result != vk::Result::eSuccess) { + return false; + } const auto it = std::find_if(modes.begin(), modes.end(), [&requested](vk::PresentModeKHR mode) { return mode == requested; }); @@ -70,12 +74,10 @@ void Swapchain::Create(u32 width_, u32 height_, vk::SurfaceKHR surface_) { .oldSwapchain = nullptr, }; - try { - swapchain = instance.GetDevice().createSwapchainKHR(swapchain_info); - } catch (vk::SystemError& err) { - LOG_CRITICAL(Render_Vulkan, "{}", err.what()); - UNREACHABLE(); - } + auto [swapchain_result, chain] = instance.GetDevice().createSwapchainKHR(swapchain_info); + ASSERT_MSG(swapchain_result == vk::Result::eSuccess, "Failed to create swapchain: {}", + vk::to_string(swapchain_result)); + swapchain = chain; SetupImages(); RefreshSemaphores(); @@ -119,20 +121,22 @@ void Swapchain::Present() { .pImageIndices = &image_index, }; - try { - [[maybe_unused]] vk::Result result = instance.GetPresentQueue().presentKHR(present_info); - } catch (vk::OutOfDateKHRError&) { + auto result = instance.GetPresentQueue().presentKHR(present_info); + if (result == vk::Result::eErrorOutOfDateKHR) { needs_recreation = true; - } catch (const vk::SystemError& err) { - LOG_CRITICAL(Render_Vulkan, "Swapchain presentation failed {}", err.what()); - UNREACHABLE(); + } else { + ASSERT_MSG(result == vk::Result::eSuccess, "Swapchain presentation failed: {}", + vk::to_string(result)); } frame_index = (frame_index + 1) % image_count; } void Swapchain::FindPresentFormat() { - const auto formats = instance.GetPhysicalDevice().getSurfaceFormatsKHR(surface); + const auto [formats_result, formats] = + instance.GetPhysicalDevice().getSurfaceFormatsKHR(surface); + ASSERT_MSG(formats_result == vk::Result::eSuccess, "Failed to query surface formats: {}", + vk::to_string(formats_result)); // If there is a single undefined surface format, the device doesn't care, so we'll just use // RGBA sRGB. @@ -158,8 +162,10 @@ void Swapchain::FindPresentFormat() { } void Swapchain::SetSurfaceProperties() { - const vk::SurfaceCapabilitiesKHR capabilities = + const auto [capabilities_result, capabilities] = instance.GetPhysicalDevice().getSurfaceCapabilitiesKHR(surface); + ASSERT_MSG(capabilities_result == vk::Result::eSuccess, + "Failed to query surface capabilities: {}", vk::to_string(capabilities_result)); extent = capabilities.currentExtent; if (capabilities.currentExtent.width == std::numeric_limits::max()) { @@ -207,10 +213,17 @@ void Swapchain::RefreshSemaphores() { present_ready.resize(image_count); for (vk::Semaphore& semaphore : image_acquired) { - semaphore = device.createSemaphore({}); + auto [semaphore_result, sem] = device.createSemaphore({}); + ASSERT_MSG(semaphore_result == vk::Result::eSuccess, + "Failed to create image acquired semaphore: {}", + vk::to_string(semaphore_result)); + semaphore = sem; } for (vk::Semaphore& semaphore : present_ready) { - semaphore = device.createSemaphore({}); + auto [semaphore_result, sem] = device.createSemaphore({}); + ASSERT_MSG(semaphore_result == vk::Result::eSuccess, + "Failed to create present ready semaphore: {}", vk::to_string(semaphore_result)); + semaphore = sem; } if (instance.HasDebuggingToolAttached()) { @@ -223,7 +236,10 @@ void Swapchain::RefreshSemaphores() { void Swapchain::SetupImages() { vk::Device device = instance.GetDevice(); - images = device.getSwapchainImagesKHR(swapchain); + auto [images_result, imgs] = device.getSwapchainImagesKHR(swapchain); + ASSERT_MSG(images_result == vk::Result::eSuccess, "Failed to create swapchain images: {}", + vk::to_string(images_result)); + images = std::move(imgs); image_count = static_cast(images.size()); if (instance.HasDebuggingToolAttached()) { diff --git a/src/video_core/texture_cache/image.cpp b/src/video_core/texture_cache/image.cpp index 16a9ce96a..c8c7ea18c 100644 --- a/src/video_core/texture_cache/image.cpp +++ b/src/video_core/texture_cache/image.cpp @@ -1,7 +1,6 @@ // SPDX-FileCopyrightText: Copyright 2024 shadPS4 Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later -#define VULKAN_HPP_NO_EXCEPTIONS #include #include "common/assert.h" #include "video_core/renderer_vulkan/liverpool_to_vk.h" diff --git a/src/video_core/texture_cache/image_view.cpp b/src/video_core/texture_cache/image_view.cpp index a77798e1b..db8113499 100644 --- a/src/video_core/texture_cache/image_view.cpp +++ b/src/video_core/texture_cache/image_view.cpp @@ -175,7 +175,10 @@ ImageView::ImageView(const Vulkan::Instance& instance, const ImageViewInfo& info .layerCount = info.range.extent.layers, }, }; - image_view = instance.GetDevice().createImageViewUnique(image_view_ci); + auto [view_result, view] = instance.GetDevice().createImageViewUnique(image_view_ci); + ASSERT_MSG(view_result == vk::Result::eSuccess, "Failed to create image view: {}", + vk::to_string(view_result)); + image_view = std::move(view); } ImageView::~ImageView() = default; diff --git a/src/video_core/texture_cache/sampler.cpp b/src/video_core/texture_cache/sampler.cpp index 19c92712c..ed567b9ee 100644 --- a/src/video_core/texture_cache/sampler.cpp +++ b/src/video_core/texture_cache/sampler.cpp @@ -24,7 +24,10 @@ Sampler::Sampler(const Vulkan::Instance& instance, const AmdGpu::Sampler& sample .borderColor = LiverpoolToVK::BorderColor(sampler.border_color_type), .unnormalizedCoordinates = bool(sampler.force_unnormalized), }; - handle = instance.GetDevice().createSamplerUnique(sampler_ci); + auto [sampler_result, smplr] = instance.GetDevice().createSamplerUnique(sampler_ci); + ASSERT_MSG(sampler_result == vk::Result::eSuccess, "Failed to create sampler: {}", + vk::to_string(sampler_result)); + handle = std::move(smplr); } Sampler::~Sampler() = default; diff --git a/src/video_core/texture_cache/tile_manager.cpp b/src/video_core/texture_cache/tile_manager.cpp index 7e06291e7..429afcae6 100644 --- a/src/video_core/texture_cache/tile_manager.cpp +++ b/src/video_core/texture_cache/tile_manager.cpp @@ -298,8 +298,10 @@ TileManager::TileManager(const Vulkan::Instance& instance, Vulkan::Scheduler& sc .bindingCount = static_cast(bindings.size()), .pBindings = bindings.data(), }; - static auto desc_layout = + static auto [desc_layout_result, desc_layout] = instance.GetDevice().createDescriptorSetLayoutUnique(desc_layout_ci); + ASSERT_MSG(desc_layout_result == vk::Result::eSuccess, + "Failed to create descriptor set layout: {}", vk::to_string(desc_layout_result)); const vk::PushConstantRange push_constants = { .stageFlags = vk::ShaderStageFlagBits::eCompute, @@ -314,7 +316,10 @@ TileManager::TileManager(const Vulkan::Instance& instance, Vulkan::Scheduler& sc .pushConstantRangeCount = 1, .pPushConstantRanges = &push_constants, }; - ctx.pl_layout = instance.GetDevice().createPipelineLayoutUnique(layout_info); + auto [layout_result, layout] = instance.GetDevice().createPipelineLayoutUnique(layout_info); + ASSERT_MSG(layout_result == vk::Result::eSuccess, "Failed to create pipeline layout: {}", + vk::to_string(layout_result)); + ctx.pl_layout = std::move(layout); const vk::ComputePipelineCreateInfo compute_pipeline_ci = { .stage = shader_ci,