From 730eb1dad74756256a3f839215f6dc4f97181928 Mon Sep 17 00:00:00 2001 From: ReinUsesLisp Date: Tue, 26 Feb 2019 02:09:43 -0300 Subject: vk_stream_buffer: Remove copy code path --- .../renderer_vulkan/vk_stream_buffer.cpp | 52 ++++------------------ src/video_core/renderer_vulkan/vk_stream_buffer.h | 19 ++++---- 2 files changed, 18 insertions(+), 53 deletions(-) (limited to 'src/video_core') diff --git a/src/video_core/renderer_vulkan/vk_stream_buffer.cpp b/src/video_core/renderer_vulkan/vk_stream_buffer.cpp index 1c5aefaec..58ffa42f2 100644 --- a/src/video_core/renderer_vulkan/vk_stream_buffer.cpp +++ b/src/video_core/renderer_vulkan/vk_stream_buffer.cpp @@ -23,16 +23,15 @@ constexpr u64 WATCHES_RESERVE_CHUNK = 0x1000; VKStreamBuffer::VKStreamBuffer(const VKDevice& device, VKMemoryManager& memory_manager, VKScheduler& scheduler, u64 size, vk::BufferUsageFlags usage, vk::AccessFlags access, vk::PipelineStageFlags pipeline_stage) - : device{device}, scheduler{scheduler}, - has_device_exclusive_memory{!memory_manager.IsMemoryUnified()}, - buffer_size{size}, access{access}, pipeline_stage{pipeline_stage} { + : device{device}, scheduler{scheduler}, buffer_size{size}, access{access}, pipeline_stage{ + pipeline_stage} { CreateBuffers(memory_manager, usage); ReserveWatches(WATCHES_INITIAL_RESERVE); } VKStreamBuffer::~VKStreamBuffer() = default; -std::tuple VKStreamBuffer::Reserve(u64 size, bool keep_in_host) { +std::tuple VKStreamBuffer::Reserve(u64 size) { ASSERT(size <= buffer_size); mapped_size = size; @@ -44,10 +43,7 @@ std::tuple VKStreamBuffer::Reserve(u64 size, bool ke offset = 0; } - use_device = has_device_exclusive_memory && !keep_in_host; - - const vk::Buffer buffer = use_device ? *device_buffer : *mappable_buffer; - return {mapped_pointer + offset, offset, buffer, invalidation_mark.has_value()}; + return {mapped_pointer + offset, offset, invalidation_mark.has_value()}; } VKExecutionContext VKStreamBuffer::Send(VKExecutionContext exctx, u64 size) { @@ -61,24 +57,6 @@ VKExecutionContext VKStreamBuffer::Send(VKExecutionContext exctx, u64 size) { invalidation_mark = std::nullopt; } - // Only copy to VRAM when requested. - if (use_device) { - const auto& dld = device.GetDispatchLoader(); - const u32 graphics_family = device.GetGraphicsFamily(); - const auto cmdbuf = exctx.GetCommandBuffer(); - - // Buffers are mirrored, that's why the copy is done with the same offset on both buffers. - const vk::BufferCopy copy_region(offset, offset, size); - cmdbuf.copyBuffer(*mappable_buffer, *device_buffer, {copy_region}, dld); - - // Protect the buffer from GPU usage until the copy has finished. - const vk::BufferMemoryBarrier barrier(vk::AccessFlagBits::eTransferWrite, access, - graphics_family, graphics_family, *device_buffer, - offset, size); - cmdbuf.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer, pipeline_stage, {}, {}, - {barrier}, {}, dld); - } - if (used_watches + 1 >= watches.size()) { // Ensure that there are enough watches. ReserveWatches(WATCHES_RESERVE_CHUNK); @@ -92,26 +70,14 @@ VKExecutionContext VKStreamBuffer::Send(VKExecutionContext exctx, u64 size) { } void VKStreamBuffer::CreateBuffers(VKMemoryManager& memory_manager, vk::BufferUsageFlags usage) { - vk::BufferUsageFlags mappable_usage = usage; - if (has_device_exclusive_memory) { - mappable_usage |= vk::BufferUsageFlagBits::eTransferSrc; - } - const vk::BufferCreateInfo buffer_ci({}, buffer_size, mappable_usage, - vk::SharingMode::eExclusive, 0, nullptr); + const vk::BufferCreateInfo buffer_ci({}, buffer_size, usage, vk::SharingMode::eExclusive, 0, + nullptr); const auto dev = device.GetLogical(); const auto& dld = device.GetDispatchLoader(); - mappable_buffer = dev.createBufferUnique(buffer_ci, nullptr, dld); - mappable_commit = memory_manager.Commit(*mappable_buffer, true); - mapped_pointer = mappable_commit->GetData(); - - if (has_device_exclusive_memory) { - const vk::BufferCreateInfo buffer_ci({}, buffer_size, - usage | vk::BufferUsageFlagBits::eTransferDst, - vk::SharingMode::eExclusive, 0, nullptr); - device_buffer = dev.createBufferUnique(buffer_ci, nullptr, dld); - device_commit = memory_manager.Commit(*device_buffer, false); - } + buffer = dev.createBufferUnique(buffer_ci, nullptr, dld); + commit = memory_manager.Commit(*buffer, true); + mapped_pointer = commit->GetData(); } void VKStreamBuffer::ReserveWatches(std::size_t grow_size) { diff --git a/src/video_core/renderer_vulkan/vk_stream_buffer.h b/src/video_core/renderer_vulkan/vk_stream_buffer.h index 8c00d383a..69d036ccd 100644 --- a/src/video_core/renderer_vulkan/vk_stream_buffer.h +++ b/src/video_core/renderer_vulkan/vk_stream_buffer.h @@ -31,15 +31,18 @@ public: /** * Reserves a region of memory from the stream buffer. * @param size Size to reserve. - * @param keep_in_host Mapped buffer will be in host memory, skipping the copy to device local. * @returns A tuple in the following order: Raw memory pointer (with offset added), buffer - * offset, Vulkan buffer handle, buffer has been invalited. + * offset and a boolean that's true when buffer has been invalidated. */ - std::tuple Reserve(u64 size, bool keep_in_host); + std::tuple Reserve(u64 size); /// Ensures that "size" bytes of memory are available to the GPU, potentially recording a copy. [[nodiscard]] VKExecutionContext Send(VKExecutionContext exctx, u64 size); + vk::Buffer GetBuffer() const { + return *buffer; + } + private: /// Creates Vulkan buffer handles committing the required the required memory. void CreateBuffers(VKMemoryManager& memory_manager, vk::BufferUsageFlags usage); @@ -50,19 +53,15 @@ private: const VKDevice& device; ///< Vulkan device manager. VKScheduler& scheduler; ///< Command scheduler. const u64 buffer_size; ///< Total size of the stream buffer. - const bool has_device_exclusive_memory; ///< True if the streaming buffer will use VRAM. const vk::AccessFlags access; ///< Access usage of this stream buffer. const vk::PipelineStageFlags pipeline_stage; ///< Pipeline usage of this stream buffer. - UniqueBuffer mappable_buffer; ///< Mapped buffer. - UniqueBuffer device_buffer; ///< Buffer exclusive to the GPU. - VKMemoryCommit mappable_commit; ///< Commit visible from the CPU. - VKMemoryCommit device_commit; ///< Commit stored in VRAM. - u8* mapped_pointer{}; ///< Pointer to the host visible commit + UniqueBuffer buffer; ///< Mapped buffer. + VKMemoryCommit commit; ///< Memory commit. + u8* mapped_pointer{}; ///< Pointer to the host visible commit u64 offset{}; ///< Buffer iterator. u64 mapped_size{}; ///< Size reserved for the current copy. - bool use_device{}; ///< True if the current uses VRAM. std::vector> watches; ///< Total watches std::size_t used_watches{}; ///< Count of watches, reset on invalidation. -- cgit v1.2.3