2019-12-25 22:12:17 +01:00
|
|
|
// Copyright 2019 yuzu Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
|
|
#include <algorithm>
|
|
|
|
#include <unordered_map>
|
|
|
|
#include <utility>
|
|
|
|
#include <vector>
|
|
|
|
|
|
|
|
#include "common/bit_util.h"
|
|
|
|
#include "common/common_types.h"
|
|
|
|
#include "video_core/renderer_vulkan/vk_device.h"
|
|
|
|
#include "video_core/renderer_vulkan/vk_scheduler.h"
|
|
|
|
#include "video_core/renderer_vulkan/vk_staging_buffer_pool.h"
|
2020-12-25 01:30:11 +01:00
|
|
|
#include "video_core/vulkan_common/vulkan_wrapper.h"
|
2019-12-25 22:12:17 +01:00
|
|
|
|
|
|
|
namespace Vulkan {
|
|
|
|
|
2020-09-10 08:43:30 +02:00
|
|
|
VKStagingBufferPool::StagingBuffer::StagingBuffer(std::unique_ptr<VKBuffer> buffer_)
|
|
|
|
: buffer{std::move(buffer_)} {}
|
2019-12-25 22:12:17 +01:00
|
|
|
|
2020-12-26 05:10:53 +01:00
|
|
|
VKStagingBufferPool::VKStagingBufferPool(const Device& device_, VKMemoryManager& memory_manager_,
|
2020-09-10 08:43:30 +02:00
|
|
|
VKScheduler& scheduler_)
|
|
|
|
: device{device_}, memory_manager{memory_manager_}, scheduler{scheduler_} {}
|
2019-12-25 22:12:17 +01:00
|
|
|
|
|
|
|
VKStagingBufferPool::~VKStagingBufferPool() = default;
|
|
|
|
|
|
|
|
VKBuffer& VKStagingBufferPool::GetUnusedBuffer(std::size_t size, bool host_visible) {
|
|
|
|
if (const auto buffer = TryGetReservedBuffer(size, host_visible)) {
|
|
|
|
return *buffer;
|
|
|
|
}
|
|
|
|
return CreateStagingBuffer(size, host_visible);
|
|
|
|
}
|
|
|
|
|
|
|
|
void VKStagingBufferPool::TickFrame() {
|
|
|
|
current_delete_level = (current_delete_level + 1) % NumLevels;
|
|
|
|
|
|
|
|
ReleaseCache(true);
|
2020-04-22 02:46:58 +02:00
|
|
|
ReleaseCache(false);
|
2019-12-25 22:12:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
VKBuffer* VKStagingBufferPool::TryGetReservedBuffer(std::size_t size, bool host_visible) {
|
2020-09-10 08:43:30 +02:00
|
|
|
for (StagingBuffer& entry : GetCache(host_visible)[Common::Log2Ceil64(size)].entries) {
|
|
|
|
if (!scheduler.IsFree(entry.tick)) {
|
|
|
|
continue;
|
2019-12-25 22:12:17 +01:00
|
|
|
}
|
2020-09-10 08:43:30 +02:00
|
|
|
entry.tick = scheduler.CurrentTick();
|
|
|
|
return &*entry.buffer;
|
2019-12-25 22:12:17 +01:00
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
VKBuffer& VKStagingBufferPool::CreateStagingBuffer(std::size_t size, bool host_visible) {
|
|
|
|
const u32 log2 = Common::Log2Ceil64(size);
|
2020-03-27 05:33:21 +01:00
|
|
|
|
2019-12-25 22:12:17 +01:00
|
|
|
auto buffer = std::make_unique<VKBuffer>();
|
2020-07-17 01:19:24 +02:00
|
|
|
buffer->handle = device.GetLogical().CreateBuffer({
|
|
|
|
.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
|
|
|
|
.pNext = nullptr,
|
|
|
|
.flags = 0,
|
|
|
|
.size = 1ULL << log2,
|
|
|
|
.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT |
|
|
|
|
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT | VK_BUFFER_USAGE_STORAGE_BUFFER_BIT |
|
|
|
|
VK_BUFFER_USAGE_INDEX_BUFFER_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
|
|
|
|
.sharingMode = VK_SHARING_MODE_EXCLUSIVE,
|
|
|
|
.queueFamilyIndexCount = 0,
|
|
|
|
.pQueueFamilyIndices = nullptr,
|
|
|
|
});
|
2020-03-27 05:33:21 +01:00
|
|
|
buffer->commit = memory_manager.Commit(buffer->handle, host_visible);
|
2019-12-25 22:12:17 +01:00
|
|
|
|
2020-09-10 08:43:30 +02:00
|
|
|
std::vector<StagingBuffer>& entries = GetCache(host_visible)[log2].entries;
|
|
|
|
StagingBuffer& entry = entries.emplace_back(std::move(buffer));
|
|
|
|
entry.tick = scheduler.CurrentTick();
|
|
|
|
return *entry.buffer;
|
2019-12-25 22:12:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
VKStagingBufferPool::StagingBuffersCache& VKStagingBufferPool::GetCache(bool host_visible) {
|
2020-04-22 02:46:58 +02:00
|
|
|
return host_visible ? host_staging_buffers : device_staging_buffers;
|
2019-12-25 22:12:17 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void VKStagingBufferPool::ReleaseCache(bool host_visible) {
|
|
|
|
auto& cache = GetCache(host_visible);
|
|
|
|
const u64 size = ReleaseLevel(cache, current_delete_level);
|
|
|
|
if (size == 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
u64 VKStagingBufferPool::ReleaseLevel(StagingBuffersCache& cache, std::size_t log2) {
|
|
|
|
static constexpr std::size_t deletions_per_tick = 16;
|
|
|
|
|
|
|
|
auto& staging = cache[log2];
|
|
|
|
auto& entries = staging.entries;
|
|
|
|
const std::size_t old_size = entries.size();
|
|
|
|
|
2020-09-10 08:43:30 +02:00
|
|
|
const auto is_deleteable = [this](const StagingBuffer& entry) {
|
|
|
|
return scheduler.IsFree(entry.tick);
|
2019-12-25 22:12:17 +01:00
|
|
|
};
|
|
|
|
const std::size_t begin_offset = staging.delete_index;
|
|
|
|
const std::size_t end_offset = std::min(begin_offset + deletions_per_tick, old_size);
|
|
|
|
const auto begin = std::begin(entries) + begin_offset;
|
|
|
|
const auto end = std::begin(entries) + end_offset;
|
|
|
|
entries.erase(std::remove_if(begin, end, is_deleteable), end);
|
|
|
|
|
|
|
|
const std::size_t new_size = entries.size();
|
|
|
|
staging.delete_index += deletions_per_tick;
|
|
|
|
if (staging.delete_index >= new_size) {
|
|
|
|
staging.delete_index = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return (1ULL << log2) * (old_size - new_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace Vulkan
|