2019-07-19 16:50:40 +02:00
|
|
|
// Copyright 2019 yuzu Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
2020-02-16 15:08:07 +01:00
|
|
|
#include <list>
|
2019-07-19 16:50:40 +02:00
|
|
|
#include <memory>
|
|
|
|
#include <mutex>
|
|
|
|
#include <unordered_map>
|
|
|
|
#include <unordered_set>
|
|
|
|
#include <utility>
|
|
|
|
#include <vector>
|
|
|
|
|
2020-05-21 04:55:40 +02:00
|
|
|
#include <boost/container/small_vector.hpp>
|
2019-11-07 07:25:53 +01:00
|
|
|
#include <boost/icl/interval_set.hpp>
|
2020-05-17 21:56:08 +02:00
|
|
|
#include <boost/intrusive/set.hpp>
|
2019-11-07 07:25:53 +01:00
|
|
|
|
2019-07-19 16:50:40 +02:00
|
|
|
#include "common/alignment.h"
|
2020-05-17 21:56:08 +02:00
|
|
|
#include "common/assert.h"
|
2019-07-19 16:50:40 +02:00
|
|
|
#include "common/common_types.h"
|
2020-03-17 01:43:05 +01:00
|
|
|
#include "common/logging/log.h"
|
2019-07-19 16:50:40 +02:00
|
|
|
#include "core/core.h"
|
2020-04-09 00:09:16 +02:00
|
|
|
#include "core/memory.h"
|
2020-02-18 22:20:39 +01:00
|
|
|
#include "core/settings.h"
|
2019-07-19 16:50:40 +02:00
|
|
|
#include "video_core/buffer_cache/buffer_block.h"
|
2019-07-19 19:22:27 +02:00
|
|
|
#include "video_core/buffer_cache/map_interval.h"
|
2019-07-19 16:50:40 +02:00
|
|
|
#include "video_core/memory_manager.h"
|
2019-08-30 20:08:00 +02:00
|
|
|
#include "video_core/rasterizer_interface.h"
|
2019-07-19 16:50:40 +02:00
|
|
|
|
|
|
|
namespace VideoCommon {
|
|
|
|
|
2020-04-04 07:54:55 +02:00
|
|
|
template <typename OwnerBuffer, typename BufferType, typename StreamBuffer>
|
2019-07-19 16:50:40 +02:00
|
|
|
class BufferCache {
|
2020-05-21 04:55:40 +02:00
|
|
|
using IntervalSet = boost::icl::interval_set<VAddr>;
|
|
|
|
using IntervalType = typename IntervalSet::interval_type;
|
|
|
|
using VectorMapInterval = boost::container::small_vector<MapInterval*, 1>;
|
|
|
|
|
2019-07-19 16:50:40 +02:00
|
|
|
public:
|
2020-04-04 07:54:55 +02:00
|
|
|
using BufferInfo = std::pair<BufferType, u64>;
|
2019-07-19 16:50:40 +02:00
|
|
|
|
|
|
|
BufferInfo UploadMemory(GPUVAddr gpu_addr, std::size_t size, std::size_t alignment = 4,
|
2019-11-02 08:08:31 +01:00
|
|
|
bool is_written = false, bool use_fast_cbuf = false) {
|
2019-07-19 16:50:40 +02:00
|
|
|
std::lock_guard lock{mutex};
|
|
|
|
|
2020-05-16 22:08:33 +02:00
|
|
|
const auto& memory_manager = system.GPU().MemoryManager();
|
|
|
|
const std::optional<VAddr> cpu_addr_opt = memory_manager.GpuToCpuAddress(gpu_addr);
|
2020-04-05 23:23:49 +02:00
|
|
|
if (!cpu_addr_opt) {
|
2019-07-19 16:50:40 +02:00
|
|
|
return {GetEmptyBuffer(size), 0};
|
|
|
|
}
|
2020-05-16 22:08:33 +02:00
|
|
|
const VAddr cpu_addr = *cpu_addr_opt;
|
2019-07-19 16:50:40 +02:00
|
|
|
|
2019-07-20 17:42:53 +02:00
|
|
|
// Cache management is a big overhead, so only cache entries with a given size.
|
|
|
|
// TODO: Figure out which size is the best for given games.
|
|
|
|
constexpr std::size_t max_stream_size = 0x800;
|
2019-11-02 08:08:31 +01:00
|
|
|
if (use_fast_cbuf || size < max_stream_size) {
|
2020-04-05 23:23:49 +02:00
|
|
|
if (!is_written && !IsRegionWritten(cpu_addr, cpu_addr + size - 1)) {
|
|
|
|
auto& memory_manager = system.GPU().MemoryManager();
|
2020-05-28 04:05:50 +02:00
|
|
|
const bool is_granular = memory_manager.IsGranularRange(gpu_addr, size);
|
2019-11-02 08:08:31 +01:00
|
|
|
if (use_fast_cbuf) {
|
2020-05-28 04:05:50 +02:00
|
|
|
u8* dest;
|
|
|
|
if (is_granular) {
|
|
|
|
dest = memory_manager.GetPointer(gpu_addr);
|
2020-04-05 23:23:49 +02:00
|
|
|
} else {
|
|
|
|
staging_buffer.resize(size);
|
2020-05-28 04:05:50 +02:00
|
|
|
dest = staging_buffer.data();
|
|
|
|
memory_manager.ReadBlockUnsafe(gpu_addr, dest, size);
|
2020-04-05 23:23:49 +02:00
|
|
|
}
|
2020-05-28 04:05:50 +02:00
|
|
|
return ConstBufferUpload(dest, size);
|
|
|
|
}
|
|
|
|
if (is_granular) {
|
|
|
|
u8* const host_ptr = memory_manager.GetPointer(gpu_addr);
|
|
|
|
return StreamBufferUpload(size, alignment, [host_ptr, size](u8* dest) {
|
|
|
|
std::memcpy(dest, host_ptr, size);
|
|
|
|
});
|
2019-11-02 08:08:31 +01:00
|
|
|
} else {
|
2020-05-28 04:05:50 +02:00
|
|
|
return StreamBufferUpload(
|
|
|
|
size, alignment, [&memory_manager, gpu_addr, size](u8* dest) {
|
|
|
|
memory_manager.ReadBlockUnsafe(gpu_addr, dest, size);
|
|
|
|
});
|
2019-11-02 08:08:31 +01:00
|
|
|
}
|
2019-07-20 17:42:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-17 21:56:08 +02:00
|
|
|
OwnerBuffer block = GetBlock(cpu_addr, size);
|
2020-05-16 23:07:03 +02:00
|
|
|
MapInterval* const map = MapAddress(block, gpu_addr, cpu_addr, size);
|
|
|
|
if (!map) {
|
|
|
|
return {GetEmptyBuffer(size), 0};
|
|
|
|
}
|
2019-07-20 17:42:53 +02:00
|
|
|
if (is_written) {
|
|
|
|
map->MarkAsModified(true, GetModifiedTicks());
|
2020-02-18 22:20:39 +01:00
|
|
|
if (Settings::IsGPULevelHigh() && Settings::values.use_asynchronous_gpu_emulation) {
|
2020-02-19 15:49:07 +01:00
|
|
|
MarkForAsyncFlush(map);
|
2020-02-18 22:20:39 +01:00
|
|
|
}
|
2020-05-16 22:08:33 +02:00
|
|
|
if (!map->is_written) {
|
|
|
|
map->is_written = true;
|
|
|
|
MarkRegionAsWritten(map->start, map->end - 1);
|
2019-07-20 17:42:53 +02:00
|
|
|
}
|
|
|
|
}
|
2019-07-19 16:50:40 +02:00
|
|
|
|
2020-04-04 07:54:55 +02:00
|
|
|
return {ToHandle(block), static_cast<u64>(block->GetOffset(cpu_addr))};
|
2019-07-19 16:50:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Uploads from a host memory. Returns the OpenGL buffer where it's located and its offset.
|
|
|
|
BufferInfo UploadHostMemory(const void* raw_pointer, std::size_t size,
|
|
|
|
std::size_t alignment = 4) {
|
|
|
|
std::lock_guard lock{mutex};
|
2020-05-28 04:05:50 +02:00
|
|
|
return StreamBufferUpload(size, alignment, [raw_pointer, size](u8* dest) {
|
|
|
|
std::memcpy(dest, raw_pointer, size);
|
|
|
|
});
|
2019-07-19 16:50:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void Map(std::size_t max_size) {
|
2019-07-20 18:54:31 +02:00
|
|
|
std::lock_guard lock{mutex};
|
|
|
|
|
2019-07-19 16:50:40 +02:00
|
|
|
std::tie(buffer_ptr, buffer_offset_base, invalidated) = stream_buffer->Map(max_size, 4);
|
|
|
|
buffer_offset = buffer_offset_base;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Finishes the upload stream, returns true on bindings invalidation.
|
|
|
|
bool Unmap() {
|
2019-07-20 18:54:31 +02:00
|
|
|
std::lock_guard lock{mutex};
|
|
|
|
|
2019-07-19 16:50:40 +02:00
|
|
|
stream_buffer->Unmap(buffer_offset - buffer_offset_base);
|
|
|
|
return std::exchange(invalidated, false);
|
|
|
|
}
|
|
|
|
|
|
|
|
void TickFrame() {
|
|
|
|
++epoch;
|
|
|
|
while (!pending_destruction.empty()) {
|
2020-01-21 20:27:43 +01:00
|
|
|
// Delay at least 4 frames before destruction.
|
|
|
|
// This is due to triple buffering happening on some drivers.
|
|
|
|
static constexpr u64 epochs_to_destroy = 5;
|
|
|
|
if (pending_destruction.front()->GetEpoch() + epochs_to_destroy > epoch) {
|
2019-07-19 16:50:40 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
pending_destruction.pop_front();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Write any cached resources overlapping the specified region back to memory
|
2020-04-05 23:23:49 +02:00
|
|
|
void FlushRegion(VAddr addr, std::size_t size) {
|
2019-07-19 16:50:40 +02:00
|
|
|
std::lock_guard lock{mutex};
|
|
|
|
|
2020-05-21 04:55:40 +02:00
|
|
|
VectorMapInterval objects = GetMapsInRange(addr, size);
|
2020-05-16 23:07:03 +02:00
|
|
|
std::sort(objects.begin(), objects.end(),
|
|
|
|
[](MapInterval* lhs, MapInterval* rhs) { return lhs->ticks < rhs->ticks; });
|
|
|
|
for (MapInterval* object : objects) {
|
2020-05-16 22:08:33 +02:00
|
|
|
if (object->is_modified && object->is_registered) {
|
2020-02-16 15:08:07 +01:00
|
|
|
mutex.unlock();
|
2019-07-20 18:54:31 +02:00
|
|
|
FlushMap(object);
|
2020-02-16 15:08:07 +01:00
|
|
|
mutex.lock();
|
2019-07-20 18:54:31 +02:00
|
|
|
}
|
|
|
|
}
|
2019-07-19 16:50:40 +02:00
|
|
|
}
|
|
|
|
|
2020-02-18 03:29:04 +01:00
|
|
|
bool MustFlushRegion(VAddr addr, std::size_t size) {
|
|
|
|
std::lock_guard lock{mutex};
|
|
|
|
|
2020-05-21 04:55:40 +02:00
|
|
|
const VectorMapInterval objects = GetMapsInRange(addr, size);
|
2020-05-16 23:07:03 +02:00
|
|
|
return std::any_of(objects.cbegin(), objects.cend(), [](const MapInterval* map) {
|
2020-05-16 22:08:33 +02:00
|
|
|
return map->is_modified && map->is_registered;
|
2020-04-16 18:29:53 +02:00
|
|
|
});
|
2020-02-18 03:29:04 +01:00
|
|
|
}
|
|
|
|
|
2019-07-19 16:50:40 +02:00
|
|
|
/// Mark the specified region as being invalidated
|
2020-04-05 23:23:49 +02:00
|
|
|
void InvalidateRegion(VAddr addr, u64 size) {
|
2019-07-19 16:50:40 +02:00
|
|
|
std::lock_guard lock{mutex};
|
|
|
|
|
2020-05-21 04:55:40 +02:00
|
|
|
for (auto& object : GetMapsInRange(addr, size)) {
|
2020-05-16 22:08:33 +02:00
|
|
|
if (object->is_registered) {
|
2019-07-20 03:07:28 +02:00
|
|
|
Unregister(object);
|
|
|
|
}
|
2019-07-19 16:50:40 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-16 15:08:07 +01:00
|
|
|
void OnCPUWrite(VAddr addr, std::size_t size) {
|
|
|
|
std::lock_guard lock{mutex};
|
|
|
|
|
2020-05-16 23:07:03 +02:00
|
|
|
for (MapInterval* object : GetMapsInRange(addr, size)) {
|
2020-05-16 22:08:33 +02:00
|
|
|
if (object->is_memory_marked && object->is_registered) {
|
2020-04-22 17:14:40 +02:00
|
|
|
UnmarkMemory(object);
|
2020-05-16 22:08:33 +02:00
|
|
|
object->is_sync_pending = true;
|
2020-02-16 15:08:07 +01:00
|
|
|
marked_for_unregister.emplace_back(object);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void SyncGuestHost() {
|
|
|
|
std::lock_guard lock{mutex};
|
|
|
|
|
2020-05-16 23:07:03 +02:00
|
|
|
for (auto& object : marked_for_unregister) {
|
2020-05-16 22:08:33 +02:00
|
|
|
if (object->is_registered) {
|
|
|
|
object->is_sync_pending = false;
|
2020-02-16 15:08:07 +01:00
|
|
|
Unregister(object);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
marked_for_unregister.clear();
|
|
|
|
}
|
|
|
|
|
2020-02-18 22:20:39 +01:00
|
|
|
void CommitAsyncFlushes() {
|
2020-04-16 18:29:53 +02:00
|
|
|
if (uncommitted_flushes) {
|
2020-05-16 23:07:03 +02:00
|
|
|
auto commit_list = std::make_shared<std::list<MapInterval*>>();
|
|
|
|
for (MapInterval* map : *uncommitted_flushes) {
|
2020-05-16 22:08:33 +02:00
|
|
|
if (map->is_registered && map->is_modified) {
|
2020-02-19 15:49:07 +01:00
|
|
|
// TODO(Blinkhawk): Implement backend asynchronous flushing
|
|
|
|
// AsyncFlushMap(map)
|
|
|
|
commit_list->push_back(map);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!commit_list->empty()) {
|
2020-04-16 18:29:53 +02:00
|
|
|
committed_flushes.push_back(commit_list);
|
2020-02-19 15:49:07 +01:00
|
|
|
} else {
|
2020-04-16 18:29:53 +02:00
|
|
|
committed_flushes.emplace_back();
|
2020-02-19 15:49:07 +01:00
|
|
|
}
|
|
|
|
} else {
|
2020-04-16 18:29:53 +02:00
|
|
|
committed_flushes.emplace_back();
|
2020-02-19 15:49:07 +01:00
|
|
|
}
|
2020-04-16 18:29:53 +02:00
|
|
|
uncommitted_flushes.reset();
|
2020-02-18 22:20:39 +01:00
|
|
|
}
|
|
|
|
|
2020-04-16 18:29:53 +02:00
|
|
|
bool ShouldWaitAsyncFlushes() const {
|
2020-04-22 17:14:40 +02:00
|
|
|
return !committed_flushes.empty() && committed_flushes.front() != nullptr;
|
2020-02-18 22:20:39 +01:00
|
|
|
}
|
|
|
|
|
2020-04-16 18:29:53 +02:00
|
|
|
bool HasUncommittedFlushes() const {
|
|
|
|
return uncommitted_flushes != nullptr;
|
2020-02-19 18:40:37 +01:00
|
|
|
}
|
|
|
|
|
2020-02-18 22:20:39 +01:00
|
|
|
void PopAsyncFlushes() {
|
2020-04-16 18:29:53 +02:00
|
|
|
if (committed_flushes.empty()) {
|
2020-02-18 22:20:39 +01:00
|
|
|
return;
|
|
|
|
}
|
2020-04-16 18:29:53 +02:00
|
|
|
auto& flush_list = committed_flushes.front();
|
2020-02-18 22:20:39 +01:00
|
|
|
if (!flush_list) {
|
2020-04-16 18:29:53 +02:00
|
|
|
committed_flushes.pop_front();
|
2020-02-18 22:20:39 +01:00
|
|
|
return;
|
|
|
|
}
|
2020-05-16 23:07:03 +02:00
|
|
|
for (MapInterval* map : *flush_list) {
|
2020-05-16 22:08:33 +02:00
|
|
|
if (map->is_registered) {
|
2020-02-19 15:49:07 +01:00
|
|
|
// TODO(Blinkhawk): Replace this for reading the asynchronous flush
|
2020-02-18 22:20:39 +01:00
|
|
|
FlushMap(map);
|
|
|
|
}
|
|
|
|
}
|
2020-04-16 18:29:53 +02:00
|
|
|
committed_flushes.pop_front();
|
2020-02-18 22:20:39 +01:00
|
|
|
}
|
|
|
|
|
2020-04-04 07:54:55 +02:00
|
|
|
virtual BufferType GetEmptyBuffer(std::size_t size) = 0;
|
2019-07-19 16:50:40 +02:00
|
|
|
|
|
|
|
protected:
|
|
|
|
explicit BufferCache(VideoCore::RasterizerInterface& rasterizer, Core::System& system,
|
|
|
|
std::unique_ptr<StreamBuffer> stream_buffer)
|
|
|
|
: rasterizer{rasterizer}, system{system}, stream_buffer{std::move(stream_buffer)},
|
|
|
|
stream_buffer_handle{this->stream_buffer->GetHandle()} {}
|
|
|
|
|
|
|
|
~BufferCache() = default;
|
|
|
|
|
2020-04-04 07:54:55 +02:00
|
|
|
virtual BufferType ToHandle(const OwnerBuffer& storage) = 0;
|
2019-07-19 16:50:40 +02:00
|
|
|
|
2020-04-04 07:54:55 +02:00
|
|
|
virtual OwnerBuffer CreateBlock(VAddr cpu_addr, std::size_t size) = 0;
|
2019-07-19 16:50:40 +02:00
|
|
|
|
2020-04-04 07:54:55 +02:00
|
|
|
virtual void UploadBlockData(const OwnerBuffer& buffer, std::size_t offset, std::size_t size,
|
2019-07-19 16:50:40 +02:00
|
|
|
const u8* data) = 0;
|
|
|
|
|
2020-04-04 07:54:55 +02:00
|
|
|
virtual void DownloadBlockData(const OwnerBuffer& buffer, std::size_t offset, std::size_t size,
|
2019-07-19 16:50:40 +02:00
|
|
|
u8* data) = 0;
|
|
|
|
|
2020-04-04 07:54:55 +02:00
|
|
|
virtual void CopyBlock(const OwnerBuffer& src, const OwnerBuffer& dst, std::size_t src_offset,
|
2019-07-19 16:50:40 +02:00
|
|
|
std::size_t dst_offset, std::size_t size) = 0;
|
|
|
|
|
2019-11-02 08:08:31 +01:00
|
|
|
virtual BufferInfo ConstBufferUpload(const void* raw_pointer, std::size_t size) {
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2019-07-19 16:50:40 +02:00
|
|
|
/// Register an object into the cache
|
2020-05-16 23:07:03 +02:00
|
|
|
MapInterval* Register(MapInterval new_map, bool inherit_written = false) {
|
|
|
|
const VAddr cpu_addr = new_map.start;
|
2020-04-05 23:23:49 +02:00
|
|
|
if (!cpu_addr) {
|
2019-07-19 16:50:40 +02:00
|
|
|
LOG_CRITICAL(HW_GPU, "Failed to register buffer with unmapped gpu_address 0x{:016x}",
|
2020-05-16 23:07:03 +02:00
|
|
|
new_map.gpu_addr);
|
|
|
|
return nullptr;
|
2019-07-19 16:50:40 +02:00
|
|
|
}
|
2020-05-16 23:07:03 +02:00
|
|
|
const std::size_t size = new_map.end - new_map.start;
|
|
|
|
new_map.is_registered = true;
|
2020-04-05 23:23:49 +02:00
|
|
|
rasterizer.UpdatePagesCachedCount(cpu_addr, size, 1);
|
2020-05-16 23:07:03 +02:00
|
|
|
new_map.is_memory_marked = true;
|
2019-07-20 17:42:53 +02:00
|
|
|
if (inherit_written) {
|
2020-05-16 23:07:03 +02:00
|
|
|
MarkRegionAsWritten(new_map.start, new_map.end - 1);
|
|
|
|
new_map.is_written = true;
|
2019-07-20 17:42:53 +02:00
|
|
|
}
|
2020-05-21 06:06:40 +02:00
|
|
|
MapInterval* const storage = mapped_addresses_allocator.Allocate();
|
|
|
|
*storage = new_map;
|
2020-05-17 21:56:08 +02:00
|
|
|
mapped_addresses.insert(*storage);
|
|
|
|
return storage;
|
2019-07-19 16:50:40 +02:00
|
|
|
}
|
|
|
|
|
2020-05-16 23:07:03 +02:00
|
|
|
void UnmarkMemory(MapInterval* map) {
|
2020-05-16 22:08:33 +02:00
|
|
|
if (!map->is_memory_marked) {
|
2020-02-16 15:08:07 +01:00
|
|
|
return;
|
|
|
|
}
|
2020-05-16 22:08:33 +02:00
|
|
|
const std::size_t size = map->end - map->start;
|
|
|
|
rasterizer.UpdatePagesCachedCount(map->start, size, -1);
|
|
|
|
map->is_memory_marked = false;
|
2020-02-16 15:08:07 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Unregisters an object from the cache
|
2020-05-16 23:07:03 +02:00
|
|
|
void Unregister(MapInterval* map) {
|
2020-04-22 17:14:40 +02:00
|
|
|
UnmarkMemory(map);
|
2020-05-16 22:08:33 +02:00
|
|
|
map->is_registered = false;
|
|
|
|
if (map->is_sync_pending) {
|
|
|
|
map->is_sync_pending = false;
|
2020-02-16 15:08:07 +01:00
|
|
|
marked_for_unregister.remove(map);
|
|
|
|
}
|
2020-05-16 22:08:33 +02:00
|
|
|
if (map->is_written) {
|
|
|
|
UnmarkRegionAsWritten(map->start, map->end - 1);
|
2019-07-20 17:42:53 +02:00
|
|
|
}
|
2020-05-17 21:56:08 +02:00
|
|
|
const auto it = mapped_addresses.find(*map);
|
|
|
|
ASSERT(it != mapped_addresses.end());
|
|
|
|
mapped_addresses.erase(it);
|
2020-05-21 06:06:40 +02:00
|
|
|
mapped_addresses_allocator.Release(map);
|
2019-07-19 16:50:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2020-05-16 23:07:03 +02:00
|
|
|
MapInterval* MapAddress(const OwnerBuffer& block, GPUVAddr gpu_addr, VAddr cpu_addr,
|
|
|
|
std::size_t size) {
|
2020-05-21 04:55:40 +02:00
|
|
|
const VectorMapInterval overlaps = GetMapsInRange(cpu_addr, size);
|
2019-07-19 16:50:40 +02:00
|
|
|
if (overlaps.empty()) {
|
2020-04-05 23:23:49 +02:00
|
|
|
auto& memory_manager = system.GPU().MemoryManager();
|
|
|
|
const VAddr cpu_addr_end = cpu_addr + size;
|
2020-04-08 18:08:06 +02:00
|
|
|
if (memory_manager.IsGranularRange(gpu_addr, size)) {
|
2020-04-05 23:23:49 +02:00
|
|
|
u8* host_ptr = memory_manager.GetPointer(gpu_addr);
|
|
|
|
UploadBlockData(block, block->GetOffset(cpu_addr), size, host_ptr);
|
|
|
|
} else {
|
|
|
|
staging_buffer.resize(size);
|
|
|
|
memory_manager.ReadBlockUnsafe(gpu_addr, staging_buffer.data(), size);
|
|
|
|
UploadBlockData(block, block->GetOffset(cpu_addr), size, staging_buffer.data());
|
|
|
|
}
|
2020-05-16 23:07:03 +02:00
|
|
|
return Register(MapInterval(cpu_addr, cpu_addr_end, gpu_addr));
|
2019-07-19 16:50:40 +02:00
|
|
|
}
|
|
|
|
|
2020-04-05 23:23:49 +02:00
|
|
|
const VAddr cpu_addr_end = cpu_addr + size;
|
2019-07-19 16:50:40 +02:00
|
|
|
if (overlaps.size() == 1) {
|
2020-05-16 23:07:03 +02:00
|
|
|
MapInterval* const current_map = overlaps[0];
|
2020-04-05 23:23:49 +02:00
|
|
|
if (current_map->IsInside(cpu_addr, cpu_addr_end)) {
|
2019-07-20 17:42:53 +02:00
|
|
|
return current_map;
|
2019-07-19 16:50:40 +02:00
|
|
|
}
|
2019-07-19 19:22:27 +02:00
|
|
|
}
|
2020-04-05 23:23:49 +02:00
|
|
|
VAddr new_start = cpu_addr;
|
|
|
|
VAddr new_end = cpu_addr_end;
|
2019-07-20 17:42:53 +02:00
|
|
|
bool write_inheritance = false;
|
2019-07-20 18:54:31 +02:00
|
|
|
bool modified_inheritance = false;
|
2019-07-19 19:22:27 +02:00
|
|
|
// Calculate new buffer parameters
|
2020-05-16 23:07:03 +02:00
|
|
|
for (MapInterval* overlap : overlaps) {
|
2020-05-16 22:08:33 +02:00
|
|
|
new_start = std::min(overlap->start, new_start);
|
|
|
|
new_end = std::max(overlap->end, new_end);
|
|
|
|
write_inheritance |= overlap->is_written;
|
|
|
|
modified_inheritance |= overlap->is_modified;
|
2019-07-19 19:22:27 +02:00
|
|
|
}
|
2020-04-05 23:23:49 +02:00
|
|
|
GPUVAddr new_gpu_addr = gpu_addr + new_start - cpu_addr;
|
2019-07-19 19:22:27 +02:00
|
|
|
for (auto& overlap : overlaps) {
|
|
|
|
Unregister(overlap);
|
|
|
|
}
|
|
|
|
UpdateBlock(block, new_start, new_end, overlaps);
|
2020-05-16 23:07:03 +02:00
|
|
|
|
|
|
|
const MapInterval new_map{new_start, new_end, new_gpu_addr};
|
|
|
|
MapInterval* const map = Register(new_map, write_inheritance);
|
|
|
|
if (!map) {
|
|
|
|
return nullptr;
|
|
|
|
}
|
2019-07-20 18:54:31 +02:00
|
|
|
if (modified_inheritance) {
|
2020-05-16 23:07:03 +02:00
|
|
|
map->MarkAsModified(true, GetModifiedTicks());
|
2020-02-18 22:20:39 +01:00
|
|
|
if (Settings::IsGPULevelHigh() && Settings::values.use_asynchronous_gpu_emulation) {
|
2020-05-16 23:07:03 +02:00
|
|
|
MarkForAsyncFlush(map);
|
2020-02-18 22:20:39 +01:00
|
|
|
}
|
2019-07-20 18:54:31 +02:00
|
|
|
}
|
2020-05-16 23:07:03 +02:00
|
|
|
return map;
|
2019-07-19 19:22:27 +02:00
|
|
|
}
|
|
|
|
|
2020-04-04 07:54:55 +02:00
|
|
|
void UpdateBlock(const OwnerBuffer& block, VAddr start, VAddr end,
|
2020-05-21 04:55:40 +02:00
|
|
|
const VectorMapInterval& overlaps) {
|
2019-07-19 19:22:27 +02:00
|
|
|
const IntervalType base_interval{start, end};
|
2019-07-20 03:07:28 +02:00
|
|
|
IntervalSet interval_set{};
|
2019-07-19 19:22:27 +02:00
|
|
|
interval_set.add(base_interval);
|
|
|
|
for (auto& overlap : overlaps) {
|
2020-05-16 22:08:33 +02:00
|
|
|
const IntervalType subtract{overlap->start, overlap->end};
|
2019-07-19 19:22:27 +02:00
|
|
|
interval_set.subtract(subtract);
|
|
|
|
}
|
|
|
|
for (auto& interval : interval_set) {
|
|
|
|
std::size_t size = interval.upper() - interval.lower();
|
|
|
|
if (size > 0) {
|
2020-04-05 23:23:49 +02:00
|
|
|
staging_buffer.resize(size);
|
|
|
|
system.Memory().ReadBlockUnsafe(interval.lower(), staging_buffer.data(), size);
|
|
|
|
UploadBlockData(block, block->GetOffset(interval.lower()), size,
|
|
|
|
staging_buffer.data());
|
2019-07-19 16:50:40 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-21 04:55:40 +02:00
|
|
|
VectorMapInterval GetMapsInRange(VAddr addr, std::size_t size) {
|
|
|
|
VectorMapInterval result;
|
2019-07-19 16:50:40 +02:00
|
|
|
if (size == 0) {
|
2020-05-21 04:55:40 +02:00
|
|
|
return result;
|
2019-07-19 16:50:40 +02:00
|
|
|
}
|
|
|
|
|
2020-05-17 21:56:08 +02:00
|
|
|
const VAddr addr_end = addr + size;
|
|
|
|
auto it = mapped_addresses.lower_bound(addr);
|
|
|
|
if (it != mapped_addresses.begin()) {
|
|
|
|
--it;
|
|
|
|
}
|
|
|
|
while (it != mapped_addresses.end() && it->start < addr_end) {
|
|
|
|
if (it->Overlaps(addr, addr_end)) {
|
|
|
|
result.push_back(&*it);
|
|
|
|
}
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
return result;
|
2019-07-19 16:50:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Returns a ticks counter used for tracking when cached objects were last modified
|
|
|
|
u64 GetModifiedTicks() {
|
|
|
|
return ++modified_ticks;
|
|
|
|
}
|
|
|
|
|
2020-05-16 23:07:03 +02:00
|
|
|
void FlushMap(MapInterval* map) {
|
|
|
|
const std::size_t size = map->end - map->start;
|
2020-05-16 22:08:33 +02:00
|
|
|
OwnerBuffer block = blocks[map->start >> block_page_bits];
|
2020-04-05 23:23:49 +02:00
|
|
|
staging_buffer.resize(size);
|
2020-05-16 22:08:33 +02:00
|
|
|
DownloadBlockData(block, block->GetOffset(map->start), size, staging_buffer.data());
|
|
|
|
system.Memory().WriteBlockUnsafe(map->start, staging_buffer.data(), size);
|
2019-07-20 18:54:31 +02:00
|
|
|
map->MarkAsModified(false, 0);
|
|
|
|
}
|
|
|
|
|
2020-05-28 04:05:50 +02:00
|
|
|
template <typename Callable>
|
|
|
|
BufferInfo StreamBufferUpload(std::size_t size, std::size_t alignment, Callable&& callable) {
|
2019-07-19 16:50:40 +02:00
|
|
|
AlignBuffer(alignment);
|
|
|
|
const std::size_t uploaded_offset = buffer_offset;
|
2020-05-28 04:05:50 +02:00
|
|
|
callable(buffer_ptr);
|
2019-07-19 16:50:40 +02:00
|
|
|
|
|
|
|
buffer_ptr += size;
|
|
|
|
buffer_offset += size;
|
2020-04-04 07:54:55 +02:00
|
|
|
return {stream_buffer_handle, uploaded_offset};
|
2019-07-19 16:50:40 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void AlignBuffer(std::size_t alignment) {
|
|
|
|
// Align the offset, not the mapped pointer
|
|
|
|
const std::size_t offset_aligned = Common::AlignUp(buffer_offset, alignment);
|
|
|
|
buffer_ptr += offset_aligned - buffer_offset;
|
|
|
|
buffer_offset = offset_aligned;
|
|
|
|
}
|
|
|
|
|
2020-04-04 07:54:55 +02:00
|
|
|
OwnerBuffer EnlargeBlock(OwnerBuffer buffer) {
|
2019-07-19 16:50:40 +02:00
|
|
|
const std::size_t old_size = buffer->GetSize();
|
|
|
|
const std::size_t new_size = old_size + block_page_size;
|
2020-04-05 23:23:49 +02:00
|
|
|
const VAddr cpu_addr = buffer->GetCpuAddr();
|
2020-04-04 07:54:55 +02:00
|
|
|
OwnerBuffer new_buffer = CreateBlock(cpu_addr, new_size);
|
2019-07-19 16:50:40 +02:00
|
|
|
CopyBlock(buffer, new_buffer, 0, 0, old_size);
|
|
|
|
buffer->SetEpoch(epoch);
|
|
|
|
pending_destruction.push_back(buffer);
|
2020-04-05 23:23:49 +02:00
|
|
|
const VAddr cpu_addr_end = cpu_addr + new_size - 1;
|
|
|
|
u64 page_start = cpu_addr >> block_page_bits;
|
|
|
|
const u64 page_end = cpu_addr_end >> block_page_bits;
|
2019-07-19 16:50:40 +02:00
|
|
|
while (page_start <= page_end) {
|
|
|
|
blocks[page_start] = new_buffer;
|
|
|
|
++page_start;
|
|
|
|
}
|
|
|
|
return new_buffer;
|
|
|
|
}
|
|
|
|
|
2020-04-04 07:54:55 +02:00
|
|
|
OwnerBuffer MergeBlocks(OwnerBuffer first, OwnerBuffer second) {
|
2019-07-19 16:50:40 +02:00
|
|
|
const std::size_t size_1 = first->GetSize();
|
|
|
|
const std::size_t size_2 = second->GetSize();
|
2020-04-05 23:23:49 +02:00
|
|
|
const VAddr first_addr = first->GetCpuAddr();
|
|
|
|
const VAddr second_addr = second->GetCpuAddr();
|
|
|
|
const VAddr new_addr = std::min(first_addr, second_addr);
|
2019-07-19 16:50:40 +02:00
|
|
|
const std::size_t new_size = size_1 + size_2;
|
2020-04-04 07:54:55 +02:00
|
|
|
OwnerBuffer new_buffer = CreateBlock(new_addr, new_size);
|
2019-07-19 16:50:40 +02:00
|
|
|
CopyBlock(first, new_buffer, 0, new_buffer->GetOffset(first_addr), size_1);
|
|
|
|
CopyBlock(second, new_buffer, 0, new_buffer->GetOffset(second_addr), size_2);
|
|
|
|
first->SetEpoch(epoch);
|
|
|
|
second->SetEpoch(epoch);
|
|
|
|
pending_destruction.push_back(first);
|
|
|
|
pending_destruction.push_back(second);
|
2020-04-05 23:23:49 +02:00
|
|
|
const VAddr cpu_addr_end = new_addr + new_size - 1;
|
2019-07-19 16:50:40 +02:00
|
|
|
u64 page_start = new_addr >> block_page_bits;
|
2020-04-05 23:23:49 +02:00
|
|
|
const u64 page_end = cpu_addr_end >> block_page_bits;
|
2019-07-19 16:50:40 +02:00
|
|
|
while (page_start <= page_end) {
|
|
|
|
blocks[page_start] = new_buffer;
|
|
|
|
++page_start;
|
|
|
|
}
|
|
|
|
return new_buffer;
|
|
|
|
}
|
|
|
|
|
2020-04-04 07:54:55 +02:00
|
|
|
OwnerBuffer GetBlock(const VAddr cpu_addr, const std::size_t size) {
|
|
|
|
OwnerBuffer found;
|
2020-04-05 23:23:49 +02:00
|
|
|
const VAddr cpu_addr_end = cpu_addr + size - 1;
|
|
|
|
u64 page_start = cpu_addr >> block_page_bits;
|
|
|
|
const u64 page_end = cpu_addr_end >> block_page_bits;
|
2019-07-19 16:50:40 +02:00
|
|
|
while (page_start <= page_end) {
|
|
|
|
auto it = blocks.find(page_start);
|
|
|
|
if (it == blocks.end()) {
|
|
|
|
if (found) {
|
|
|
|
found = EnlargeBlock(found);
|
|
|
|
} else {
|
2020-04-05 23:23:49 +02:00
|
|
|
const VAddr start_addr = (page_start << block_page_bits);
|
2019-07-19 16:50:40 +02:00
|
|
|
found = CreateBlock(start_addr, block_page_size);
|
|
|
|
blocks[page_start] = found;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (found) {
|
|
|
|
if (found == it->second) {
|
|
|
|
++page_start;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
found = MergeBlocks(found, it->second);
|
|
|
|
} else {
|
|
|
|
found = it->second;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
++page_start;
|
|
|
|
}
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2020-04-05 23:23:49 +02:00
|
|
|
void MarkRegionAsWritten(const VAddr start, const VAddr end) {
|
2019-07-20 17:42:53 +02:00
|
|
|
u64 page_start = start >> write_page_bit;
|
|
|
|
const u64 page_end = end >> write_page_bit;
|
|
|
|
while (page_start <= page_end) {
|
|
|
|
auto it = written_pages.find(page_start);
|
|
|
|
if (it != written_pages.end()) {
|
|
|
|
it->second = it->second + 1;
|
|
|
|
} else {
|
|
|
|
written_pages[page_start] = 1;
|
|
|
|
}
|
2020-05-16 22:08:33 +02:00
|
|
|
++page_start;
|
2019-07-20 17:42:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-05 23:23:49 +02:00
|
|
|
void UnmarkRegionAsWritten(const VAddr start, const VAddr end) {
|
2019-07-20 17:42:53 +02:00
|
|
|
u64 page_start = start >> write_page_bit;
|
|
|
|
const u64 page_end = end >> write_page_bit;
|
|
|
|
while (page_start <= page_end) {
|
|
|
|
auto it = written_pages.find(page_start);
|
|
|
|
if (it != written_pages.end()) {
|
|
|
|
if (it->second > 1) {
|
|
|
|
it->second = it->second - 1;
|
|
|
|
} else {
|
|
|
|
written_pages.erase(it);
|
|
|
|
}
|
|
|
|
}
|
2020-05-16 22:08:33 +02:00
|
|
|
++page_start;
|
2019-07-20 17:42:53 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-05 23:23:49 +02:00
|
|
|
bool IsRegionWritten(const VAddr start, const VAddr end) const {
|
2019-07-20 17:42:53 +02:00
|
|
|
u64 page_start = start >> write_page_bit;
|
|
|
|
const u64 page_end = end >> write_page_bit;
|
|
|
|
while (page_start <= page_end) {
|
|
|
|
if (written_pages.count(page_start) > 0) {
|
|
|
|
return true;
|
|
|
|
}
|
2020-05-16 22:08:33 +02:00
|
|
|
++page_start;
|
2019-07-20 17:42:53 +02:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-05-16 23:07:03 +02:00
|
|
|
void MarkForAsyncFlush(MapInterval* map) {
|
2020-04-16 18:29:53 +02:00
|
|
|
if (!uncommitted_flushes) {
|
2020-05-16 23:07:03 +02:00
|
|
|
uncommitted_flushes = std::make_shared<std::unordered_set<MapInterval*>>();
|
2020-02-18 22:20:39 +01:00
|
|
|
}
|
2020-04-16 18:29:53 +02:00
|
|
|
uncommitted_flushes->insert(map);
|
2020-02-18 22:20:39 +01:00
|
|
|
}
|
|
|
|
|
2019-08-30 20:08:00 +02:00
|
|
|
VideoCore::RasterizerInterface& rasterizer;
|
|
|
|
Core::System& system;
|
|
|
|
|
2019-11-20 20:00:40 +01:00
|
|
|
std::unique_ptr<StreamBuffer> stream_buffer;
|
2020-04-04 07:54:55 +02:00
|
|
|
BufferType stream_buffer_handle{};
|
2019-07-19 16:50:40 +02:00
|
|
|
|
|
|
|
bool invalidated = false;
|
|
|
|
|
|
|
|
u8* buffer_ptr = nullptr;
|
|
|
|
u64 buffer_offset = 0;
|
|
|
|
u64 buffer_offset_base = 0;
|
|
|
|
|
2020-05-21 06:06:40 +02:00
|
|
|
MapIntervalAllocator mapped_addresses_allocator;
|
2020-05-21 04:55:40 +02:00
|
|
|
boost::intrusive::set<MapInterval, boost::intrusive::compare<MapIntervalCompare>>
|
|
|
|
mapped_addresses;
|
2019-07-19 16:50:40 +02:00
|
|
|
|
2019-11-20 20:00:40 +01:00
|
|
|
static constexpr u64 write_page_bit = 11;
|
|
|
|
std::unordered_map<u64, u32> written_pages;
|
2019-07-20 17:42:53 +02:00
|
|
|
|
2019-11-20 20:00:40 +01:00
|
|
|
static constexpr u64 block_page_bits = 21;
|
|
|
|
static constexpr u64 block_page_size = 1ULL << block_page_bits;
|
2020-04-04 07:54:55 +02:00
|
|
|
std::unordered_map<u64, OwnerBuffer> blocks;
|
2019-07-19 16:50:40 +02:00
|
|
|
|
2020-04-04 07:54:55 +02:00
|
|
|
std::list<OwnerBuffer> pending_destruction;
|
2019-11-20 20:00:40 +01:00
|
|
|
u64 epoch = 0;
|
|
|
|
u64 modified_ticks = 0;
|
2019-08-30 20:08:00 +02:00
|
|
|
|
2020-04-05 23:23:49 +02:00
|
|
|
std::vector<u8> staging_buffer;
|
2020-05-16 23:07:03 +02:00
|
|
|
std::list<MapInterval*> marked_for_unregister;
|
2020-04-05 23:23:49 +02:00
|
|
|
|
2020-05-16 23:07:03 +02:00
|
|
|
std::shared_ptr<std::unordered_set<MapInterval*>> uncommitted_flushes;
|
|
|
|
std::list<std::shared_ptr<std::list<MapInterval*>>> committed_flushes;
|
2020-02-18 22:20:39 +01:00
|
|
|
|
2019-07-19 16:50:40 +02:00
|
|
|
std::recursive_mutex mutex;
|
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace VideoCommon
|