diff options
Diffstat (limited to 'Source/Core/VideoBackends/Vulkan/StreamBuffer.cpp')
| -rw-r--r-- | Source/Core/VideoBackends/Vulkan/StreamBuffer.cpp | 124 |
1 files changed, 45 insertions, 79 deletions
diff --git a/Source/Core/VideoBackends/Vulkan/StreamBuffer.cpp b/Source/Core/VideoBackends/Vulkan/StreamBuffer.cpp index cb8e660af2..ea610f09cf 100644 --- a/Source/Core/VideoBackends/Vulkan/StreamBuffer.cpp +++ b/Source/Core/VideoBackends/Vulkan/StreamBuffer.cpp @@ -8,29 +8,24 @@ #include <cstdint> #include <functional> +#include "Common/Align.h" #include "Common/Assert.h" #include "Common/MsgHandler.h" #include "VideoBackends/Vulkan/CommandBufferManager.h" -#include "VideoBackends/Vulkan/Util.h" #include "VideoBackends/Vulkan/VulkanContext.h" namespace Vulkan { -StreamBuffer::StreamBuffer(VkBufferUsageFlags usage, size_t max_size) - : m_usage(usage), m_maximum_size(max_size) +StreamBuffer::StreamBuffer(VkBufferUsageFlags usage, u32 size) : m_usage(usage), m_size(size) { - // Add a callback that fires on fence point creation and signal - g_command_buffer_mgr->AddFencePointCallback( - this, - std::bind(&StreamBuffer::OnCommandBufferQueued, this, std::placeholders::_1, - std::placeholders::_2), - std::bind(&StreamBuffer::OnCommandBufferExecuted, this, std::placeholders::_1)); + g_command_buffer_mgr->AddFenceSignaledCallback( + this, std::bind(&StreamBuffer::OnFenceSignaled, this, std::placeholders::_1)); } StreamBuffer::~StreamBuffer() { - g_command_buffer_mgr->RemoveFencePointCallback(this); + g_command_buffer_mgr->RemoveFenceSignaledCallback(this); if (m_host_pointer) vkUnmapMemory(g_vulkan_context->GetDevice(), m_memory); @@ -41,24 +36,23 @@ StreamBuffer::~StreamBuffer() g_command_buffer_mgr->DeferDeviceMemoryDestruction(m_memory); } -std::unique_ptr<StreamBuffer> StreamBuffer::Create(VkBufferUsageFlags usage, size_t initial_size, - size_t max_size) +std::unique_ptr<StreamBuffer> StreamBuffer::Create(VkBufferUsageFlags usage, u32 size) { - std::unique_ptr<StreamBuffer> buffer = std::make_unique<StreamBuffer>(usage, max_size); - if (!buffer->ResizeBuffer(initial_size)) + std::unique_ptr<StreamBuffer> buffer = std::make_unique<StreamBuffer>(usage, size); + if (!buffer->AllocateBuffer()) return nullptr; return buffer; } -bool StreamBuffer::ResizeBuffer(size_t size) +bool StreamBuffer::AllocateBuffer() { // Create the buffer descriptor VkBufferCreateInfo buffer_create_info = { VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType nullptr, // const void* pNext 0, // VkBufferCreateFlags flags - static_cast<VkDeviceSize>(size), // VkDeviceSize size + static_cast<VkDeviceSize>(m_size), // VkDeviceSize size m_usage, // VkBufferUsageFlags usage VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode 0, // uint32_t queueFamilyIndexCount @@ -110,7 +104,7 @@ bool StreamBuffer::ResizeBuffer(size_t size) // Map this buffer into user-space void* mapped_ptr = nullptr; - res = vkMapMemory(g_vulkan_context->GetDevice(), memory, 0, size, 0, &mapped_ptr); + res = vkMapMemory(g_vulkan_context->GetDevice(), memory, 0, m_size, 0, &mapped_ptr); if (res != VK_SUCCESS) { LOG_VULKAN_ERROR(res, "vkMapMemory failed: "); @@ -133,36 +127,34 @@ bool StreamBuffer::ResizeBuffer(size_t size) m_buffer = buffer; m_memory = memory; m_host_pointer = reinterpret_cast<u8*>(mapped_ptr); - m_current_size = size; m_current_offset = 0; m_current_gpu_position = 0; m_tracked_fences.clear(); return true; } -bool StreamBuffer::ReserveMemory(size_t num_bytes, size_t alignment, bool allow_reuse /* = true */, - bool allow_growth /* = true */, - bool reallocate_if_full /* = false */) +bool StreamBuffer::ReserveMemory(u32 num_bytes, u32 alignment) { - size_t required_bytes = num_bytes + alignment; + const u32 required_bytes = num_bytes + alignment; // Check for sane allocations - if (required_bytes > m_maximum_size) + if (required_bytes > m_size) { PanicAlert("Attempting to allocate %u bytes from a %u byte stream buffer", - static_cast<uint32_t>(num_bytes), static_cast<uint32_t>(m_maximum_size)); + static_cast<uint32_t>(num_bytes), static_cast<uint32_t>(m_size)); return false; } // Is the GPU behind or up to date with our current offset? + UpdateCurrentFencePosition(); if (m_current_offset >= m_current_gpu_position) { - size_t remaining_bytes = m_current_size - m_current_offset; + const u32 remaining_bytes = m_size - m_current_offset; if (required_bytes <= remaining_bytes) { // Place at the current position, after the GPU position. - m_current_offset = Util::AlignBufferOffset(m_current_offset, alignment); + m_current_offset = Common::AlignUp(m_current_offset, alignment); m_last_allocation_size = num_bytes; return true; } @@ -171,7 +163,7 @@ bool StreamBuffer::ReserveMemory(size_t num_bytes, size_t alignment, bool allow_ // We use < here because we don't want to have the case of m_current_offset == // m_current_gpu_position. That would mean the code above would assume the // GPU has caught up to us, which it hasn't. - if (allow_reuse && required_bytes < m_current_gpu_position) + if (required_bytes < m_current_gpu_position) { // Reset offset to zero, since we're allocating behind the gpu now m_current_offset = 0; @@ -184,56 +176,35 @@ bool StreamBuffer::ReserveMemory(size_t num_bytes, size_t alignment, bool allow_ if (m_current_offset < m_current_gpu_position) { // We have from m_current_offset..m_current_gpu_position space to use. - size_t remaining_bytes = m_current_gpu_position - m_current_offset; + const u32 remaining_bytes = m_current_gpu_position - m_current_offset; if (required_bytes < remaining_bytes) { // Place at the current position, since this is still behind the GPU. - m_current_offset = Util::AlignBufferOffset(m_current_offset, alignment); + m_current_offset = Common::AlignUp(m_current_offset, alignment); m_last_allocation_size = num_bytes; return true; } } - // Try to grow the buffer up to the maximum size before waiting. - // Double each time until the maximum size is reached. - if (allow_growth && m_current_size < m_maximum_size) - { - size_t new_size = std::min(std::max(num_bytes, m_current_size * 2), m_maximum_size); - if (ResizeBuffer(new_size)) - { - // Allocating from the start of the buffer. - m_last_allocation_size = new_size; - return true; - } - } - // Can we find a fence to wait on that will give us enough memory? - if (allow_reuse && WaitForClearSpace(required_bytes)) + if (WaitForClearSpace(required_bytes)) { ASSERT(m_current_offset == m_current_gpu_position || (m_current_offset + required_bytes) < m_current_gpu_position); - m_current_offset = Util::AlignBufferOffset(m_current_offset, alignment); - m_last_allocation_size = num_bytes; - return true; - } - - // If we are not allowed to execute in our current state (e.g. in the middle of a render pass), - // as a last resort, reallocate the buffer. This will incur a performance hit and is not - // encouraged. - if (reallocate_if_full && ResizeBuffer(m_current_size)) - { + m_current_offset = Common::AlignUp(m_current_offset, alignment); m_last_allocation_size = num_bytes; return true; } - // We tried everything we could, and still couldn't get anything. If we're not at a point - // where the state is known and can be resumed, this is probably a fatal error. + // We tried everything we could, and still couldn't get anything. This means that too much space + // in the buffer is being used by the command buffer currently being recorded. Therefore, the + // only option is to execute it, and wait until it's done. return false; } -void StreamBuffer::CommitMemory(size_t final_num_bytes) +void StreamBuffer::CommitMemory(u32 final_num_bytes) { - ASSERT((m_current_offset + final_num_bytes) <= m_current_size); + ASSERT((m_current_offset + final_num_bytes) <= m_size); ASSERT(final_num_bytes <= m_last_allocation_size); // For non-coherent mappings, flush the memory range @@ -247,23 +218,25 @@ void StreamBuffer::CommitMemory(size_t final_num_bytes) m_current_offset += final_num_bytes; } -void StreamBuffer::OnCommandBufferQueued(VkCommandBuffer command_buffer, VkFence fence) +void StreamBuffer::UpdateCurrentFencePosition() { // Don't create a tracking entry if the GPU is caught up with the buffer. if (m_current_offset == m_current_gpu_position) return; // Has the offset changed since the last fence? - if (!m_tracked_fences.empty() && m_tracked_fences.back().second == m_current_offset) + const VkFence fence = g_command_buffer_mgr->GetCurrentCommandBufferFence(); + if (!m_tracked_fences.empty() && m_tracked_fences.back().first == fence) { - // No need to track the new fence, the old one is sufficient. + // Still haven't executed a command buffer, so just update the offset. + m_tracked_fences.back().second = m_current_offset; return; } m_tracked_fences.emplace_back(fence, m_current_offset); } -void StreamBuffer::OnCommandBufferExecuted(VkFence fence) +void StreamBuffer::OnFenceSignaled(VkFence fence) { // Locate the entry for this fence (if any, we may have been forced to wait already) auto iter = std::find_if(m_tracked_fences.begin(), m_tracked_fences.end(), @@ -279,10 +252,9 @@ void StreamBuffer::OnCommandBufferExecuted(VkFence fence) } } -bool StreamBuffer::WaitForClearSpace(size_t num_bytes) +bool StreamBuffer::WaitForClearSpace(u32 num_bytes) { - size_t new_offset = 0; - size_t new_gpu_position = 0; + u32 new_offset = 0; auto iter = m_tracked_fences.begin(); for (; iter != m_tracked_fences.end(); iter++) { @@ -290,12 +262,11 @@ bool StreamBuffer::WaitForClearSpace(size_t num_bytes) // This is the "last resort" case, where a command buffer execution has been forced // after no additional data has been written to it, so we can assume that after the // fence has been signaled the entire buffer is now consumed. - size_t gpu_position = iter->second; + u32 gpu_position = iter->second; if (m_current_offset == gpu_position) { // Start at the start of the buffer again. new_offset = 0; - new_gpu_position = 0; break; } @@ -308,7 +279,6 @@ bool StreamBuffer::WaitForClearSpace(size_t num_bytes) if (gpu_position > num_bytes) { new_offset = 0; - new_gpu_position = gpu_position; break; } } @@ -317,31 +287,27 @@ bool StreamBuffer::WaitForClearSpace(size_t num_bytes) // We're currently allocating behind the GPU. This would give us between the current // offset and the GPU position worth of space to work with. Again, > because we can't // align the GPU position with the buffer offset. - size_t available_space_inbetween = gpu_position - m_current_offset; + u32 available_space_inbetween = gpu_position - m_current_offset; if (available_space_inbetween > num_bytes) { // Leave the offset as-is, but update the GPU position. new_offset = m_current_offset; - new_gpu_position = gpu_position; break; } } } // Did any fences satisfy this condition? - if (iter == m_tracked_fences.end()) + // Has the command buffer been executed yet? If not, the caller should execute it. + if (iter == m_tracked_fences.end() || + iter->first == g_command_buffer_mgr->GetCurrentCommandBufferFence()) + { return false; + } - // Wait until this fence is signaled. - VkResult res = - vkWaitForFences(g_vulkan_context->GetDevice(), 1, &iter->first, VK_TRUE, UINT64_MAX); - if (res != VK_SUCCESS) - LOG_VULKAN_ERROR(res, "vkWaitForFences failed: "); - - // Update GPU position, and remove all fences up to (and including) this fence. + // Wait until this fence is signaled. This will fire the callback, updating the GPU position. + g_command_buffer_mgr->WaitForFence(iter->first); m_current_offset = new_offset; - m_current_gpu_position = new_gpu_position; - m_tracked_fences.erase(m_tracked_fences.begin(), ++iter); return true; } |