forked from suyu/suyu
58b0ae84b5
This reworks how host<->device synchronization works on the Vulkan backend. Instead of "protecting" resources with a fence and signalling these as free when the fence is known to be signalled by the host GPU, use timeline semaphores. Vulkan timeline semaphores allow use to work on a subset of D3D12 fences. As far as we are concerned, timeline semaphores are a value set by the host or the device that can be waited by either of them. Taking advantange of this, we can have a monolithically increasing atomic value for each submission to the graphics queue. Instead of protecting resources with a fence, we simply store the current logical tick (the atomic value stored in CPU memory). When we want to know if a resource is free, it can be compared to the current GPU tick. This greatly simplifies resource management code and the free status of resources should have less false negatives. To workaround bugs in validation layers, when these are attached there's a thread waiting for timeline semaphores.
78 lines
2.5 KiB
C++
78 lines
2.5 KiB
C++
// Copyright 2019 yuzu Emulator Project
|
|
// Licensed under GPLv2 or any later version
|
|
// Refer to the license.txt file included.
|
|
|
|
#pragma once
|
|
|
|
#include <optional>
|
|
#include <tuple>
|
|
#include <vector>
|
|
|
|
#include "common/common_types.h"
|
|
#include "video_core/renderer_vulkan/wrapper.h"
|
|
|
|
namespace Vulkan {
|
|
|
|
class VKDevice;
|
|
class VKFenceWatch;
|
|
class VKScheduler;
|
|
|
|
class VKStreamBuffer final {
|
|
public:
|
|
explicit VKStreamBuffer(const VKDevice& device, VKScheduler& scheduler,
|
|
VkBufferUsageFlags usage);
|
|
~VKStreamBuffer();
|
|
|
|
/**
|
|
* Reserves a region of memory from the stream buffer.
|
|
* @param size Size to reserve.
|
|
* @returns A tuple in the following order: Raw memory pointer (with offset added), buffer
|
|
* offset and a boolean that's true when buffer has been invalidated.
|
|
*/
|
|
std::tuple<u8*, u64, bool> Map(u64 size, u64 alignment);
|
|
|
|
/// Ensures that "size" bytes of memory are available to the GPU, potentially recording a copy.
|
|
void Unmap(u64 size);
|
|
|
|
VkBuffer Handle() const noexcept {
|
|
return *buffer;
|
|
}
|
|
|
|
u64 Address() const noexcept {
|
|
return 0;
|
|
}
|
|
|
|
private:
|
|
struct Watch {
|
|
u64 tick{};
|
|
u64 upper_bound{};
|
|
};
|
|
|
|
/// Creates Vulkan buffer handles committing the required the required memory.
|
|
void CreateBuffers(VkBufferUsageFlags usage);
|
|
|
|
/// Increases the amount of watches available.
|
|
void ReserveWatches(std::vector<Watch>& watches, std::size_t grow_size);
|
|
|
|
void WaitPendingOperations(u64 requested_upper_bound);
|
|
|
|
const VKDevice& device; ///< Vulkan device manager.
|
|
VKScheduler& scheduler; ///< Command scheduler.
|
|
|
|
vk::Buffer buffer; ///< Mapped buffer.
|
|
vk::DeviceMemory memory; ///< Memory allocation.
|
|
u64 stream_buffer_size{}; ///< Stream buffer size.
|
|
|
|
u64 offset{}; ///< Buffer iterator.
|
|
u64 mapped_size{}; ///< Size reserved for the current copy.
|
|
|
|
std::vector<Watch> current_watches; ///< Watches recorded in the current iteration.
|
|
std::size_t current_watch_cursor{}; ///< Count of watches, reset on invalidation.
|
|
std::optional<std::size_t> invalidation_mark; ///< Number of watches used in the previous cycle.
|
|
|
|
std::vector<Watch> previous_watches; ///< Watches used in the previous iteration.
|
|
std::size_t wait_cursor{}; ///< Last watch being waited for completion.
|
|
u64 wait_bound{}; ///< Highest offset being watched for completion.
|
|
};
|
|
|
|
} // namespace Vulkan
|