forked from suyu/suyu
90 lines
3.3 KiB
C++
90 lines
3.3 KiB
C++
// Copyright 2019 yuzu Emulator Project
|
|
// Licensed under GPLv2 or any later version
|
|
// Refer to the license.txt file included.
|
|
|
|
#include <algorithm>
|
|
#include <memory>
|
|
#include <optional>
|
|
#include <vector>
|
|
|
|
#include "common/assert.h"
|
|
#include "video_core/renderer_vulkan/declarations.h"
|
|
#include "video_core/renderer_vulkan/vk_device.h"
|
|
#include "video_core/renderer_vulkan/vk_memory_manager.h"
|
|
#include "video_core/renderer_vulkan/vk_resource_manager.h"
|
|
#include "video_core/renderer_vulkan/vk_scheduler.h"
|
|
#include "video_core/renderer_vulkan/vk_stream_buffer.h"
|
|
|
|
namespace Vulkan {
|
|
|
|
constexpr u64 WATCHES_INITIAL_RESERVE = 0x4000;
|
|
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}, buffer_size{size}, access{access}, pipeline_stage{
|
|
pipeline_stage} {
|
|
CreateBuffers(memory_manager, usage);
|
|
ReserveWatches(WATCHES_INITIAL_RESERVE);
|
|
}
|
|
|
|
VKStreamBuffer::~VKStreamBuffer() = default;
|
|
|
|
std::tuple<u8*, u64, bool> VKStreamBuffer::Reserve(u64 size) {
|
|
ASSERT(size <= buffer_size);
|
|
mapped_size = size;
|
|
|
|
if (offset + size > buffer_size) {
|
|
// The buffer would overflow, save the amount of used buffers, signal an invalidation and
|
|
// reset the state.
|
|
invalidation_mark = used_watches;
|
|
used_watches = 0;
|
|
offset = 0;
|
|
}
|
|
|
|
return {mapped_pointer + offset, offset, invalidation_mark.has_value()};
|
|
}
|
|
|
|
VKExecutionContext VKStreamBuffer::Send(VKExecutionContext exctx, u64 size) {
|
|
ASSERT_MSG(size <= mapped_size, "Reserved size is too small");
|
|
|
|
if (invalidation_mark) {
|
|
// TODO(Rodrigo): Find a better way to invalidate than waiting for all watches to finish.
|
|
exctx = scheduler.Flush();
|
|
std::for_each(watches.begin(), watches.begin() + *invalidation_mark,
|
|
[&](auto& resource) { resource->Wait(); });
|
|
invalidation_mark = std::nullopt;
|
|
}
|
|
|
|
if (used_watches + 1 >= watches.size()) {
|
|
// Ensure that there are enough watches.
|
|
ReserveWatches(WATCHES_RESERVE_CHUNK);
|
|
}
|
|
// Add a watch for this allocation.
|
|
watches[used_watches++]->Watch(exctx.GetFence());
|
|
|
|
offset += size;
|
|
|
|
return exctx;
|
|
}
|
|
|
|
void VKStreamBuffer::CreateBuffers(VKMemoryManager& memory_manager, vk::BufferUsageFlags usage) {
|
|
const vk::BufferCreateInfo buffer_ci({}, buffer_size, usage, vk::SharingMode::eExclusive, 0,
|
|
nullptr);
|
|
|
|
const auto dev = device.GetLogical();
|
|
const auto& dld = device.GetDispatchLoader();
|
|
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) {
|
|
const std::size_t previous_size = watches.size();
|
|
watches.resize(previous_size + grow_size);
|
|
std::generate(watches.begin() + previous_size, watches.end(),
|
|
[]() { return std::make_unique<VKFenceWatch>(); });
|
|
}
|
|
|
|
} // namespace Vulkan
|