From 8155b12d3d8963ec4d8727614ffb522a33389cbf Mon Sep 17 00:00:00 2001 From: ReinUsesLisp Date: Mon, 27 May 2019 20:50:11 -0300 Subject: gl_buffer_cache: Rework to support internalized buffers --- src/video_core/renderer_opengl/gl_buffer_cache.cpp | 167 +++++++++++++++------ 1 file changed, 121 insertions(+), 46 deletions(-) (limited to 'src/video_core/renderer_opengl/gl_buffer_cache.cpp') diff --git a/src/video_core/renderer_opengl/gl_buffer_cache.cpp b/src/video_core/renderer_opengl/gl_buffer_cache.cpp index b4277ef73..1219ca6ea 100644 --- a/src/video_core/renderer_opengl/gl_buffer_cache.cpp +++ b/src/video_core/renderer_opengl/gl_buffer_cache.cpp @@ -7,90 +7,165 @@ #include #include "common/alignment.h" +#include "common/assert.h" #include "core/core.h" #include "video_core/memory_manager.h" #include "video_core/renderer_opengl/gl_buffer_cache.h" #include "video_core/renderer_opengl/gl_rasterizer.h" +#include "video_core/renderer_opengl/gl_resource_manager.h" namespace OpenGL { -CachedBufferEntry::CachedBufferEntry(VAddr cpu_addr, u8* host_ptr, std::size_t size, - std::size_t alignment, GLuint buffer, GLintptr offset) - : RasterizerCacheObject{host_ptr}, cpu_addr{cpu_addr}, size{size}, alignment{alignment}, - buffer{buffer}, offset{offset} {} +namespace { + +constexpr GLuint EmptyBuffer = 0; +constexpr GLintptr CachedBufferOffset = 0; + +OGLBuffer CreateBuffer(std::size_t size, GLenum usage) { + OGLBuffer buffer; + buffer.Create(); + glNamedBufferData(buffer.handle, size, nullptr, usage); + return buffer; +} + +} // Anonymous namespace + +CachedBufferEntry::CachedBufferEntry(VAddr cpu_addr, u8* host_ptr) + : RasterizerCacheObject{host_ptr}, cpu_addr{cpu_addr} {} OGLBufferCache::OGLBufferCache(RasterizerOpenGL& rasterizer, std::size_t size) : RasterizerCache{rasterizer}, stream_buffer(size, true) {} -std::pair OGLBufferCache::UploadMemory(GPUVAddr gpu_addr, std::size_t size, - std::size_t alignment, bool cache) { +OGLBufferCache::~OGLBufferCache() = default; + +void OGLBufferCache::Unregister(const std::shared_ptr& entry) { std::lock_guard lock{mutex}; - auto& memory_manager = Core::System::GetInstance().GPU().MemoryManager(); + if (entry->IsInternalized()) { + internalized_entries.erase(entry->GetCacheAddr()); + } + ReserveBuffer(entry); + RasterizerCache>::Unregister(entry); +} + +OGLBufferCache::BufferInfo OGLBufferCache::UploadMemory(GPUVAddr gpu_addr, std::size_t size, + std::size_t alignment, bool internalize) { + std::lock_guard lock{mutex}; - const auto& host_ptr{memory_manager.GetPointer(gpu_addr)}; + auto& memory_manager = Core::System::GetInstance().GPU().MemoryManager(); + const auto host_ptr{memory_manager.GetPointer(gpu_addr)}; + const auto cache_addr{ToCacheAddr(host_ptr)}; if (!host_ptr) { - // Return a dummy buffer when host_ptr is invalid. - return {0, 0}; + return {EmptyBuffer, 0}; } // 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. - cache &= size >= 2048; - - if (cache) { - if (auto entry = TryGet(host_ptr); entry) { - if (entry->GetSize() >= size && entry->GetAlignment() == alignment) { - return {entry->GetBuffer(), entry->GetOffset()}; - } - Unregister(entry); - } + if (!internalize && size < 0x800 && + internalized_entries.find(cache_addr) == internalized_entries.end()) { + return StreamBufferUpload(host_ptr, size, alignment); } - AlignBuffer(alignment); - const GLintptr uploaded_offset = buffer_offset; - - std::memcpy(buffer_ptr, host_ptr, size); - buffer_ptr += size; - buffer_offset += size; + auto entry = TryGet(host_ptr); + if (!entry) { + return FixedBufferUpload(gpu_addr, host_ptr, size, internalize); + } - const GLuint buffer = stream_buffer.GetHandle(); - if (cache) { - const VAddr cpu_addr = *memory_manager.GpuToCpuAddress(gpu_addr); - Register(std::make_shared(cpu_addr, host_ptr, size, alignment, buffer, - uploaded_offset)); + if (entry->GetSize() < size) { + GrowBuffer(entry, size); } + return {entry->GetBuffer(), CachedBufferOffset}; +} - return {buffer, uploaded_offset}; +OGLBufferCache::BufferInfo OGLBufferCache::UploadHostMemory(const void* raw_pointer, + std::size_t size, + std::size_t alignment) { + return StreamBufferUpload(raw_pointer, size, alignment); } -std::pair OGLBufferCache::UploadHostMemory(const void* raw_pointer, - std::size_t size, - std::size_t alignment) { - std::lock_guard lock{mutex}; +bool OGLBufferCache::Map(std::size_t max_size) { + const auto max_size_ = static_cast(max_size); + bool invalidate; + std::tie(buffer_ptr, buffer_offset_base, invalidate) = stream_buffer.Map(max_size_, 4); + buffer_offset = buffer_offset_base; + return invalidate; +} + +void OGLBufferCache::Unmap() { + stream_buffer.Unmap(buffer_offset - buffer_offset_base); +} + +OGLBufferCache::BufferInfo OGLBufferCache::StreamBufferUpload(const void* raw_pointer, + std::size_t size, + std::size_t alignment) { AlignBuffer(alignment); - std::memcpy(buffer_ptr, raw_pointer, size); const GLintptr uploaded_offset = buffer_offset; + std::memcpy(buffer_ptr, raw_pointer, size); buffer_ptr += size; buffer_offset += size; return {stream_buffer.GetHandle(), uploaded_offset}; } -bool OGLBufferCache::Map(std::size_t max_size) { - bool invalidate; - std::tie(buffer_ptr, buffer_offset_base, invalidate) = - stream_buffer.Map(static_cast(max_size), 4); - buffer_offset = buffer_offset_base; +OGLBufferCache::BufferInfo OGLBufferCache::FixedBufferUpload(GPUVAddr gpu_addr, u8* host_ptr, + std::size_t size, bool internalize) { + if (internalize) { + internalized_entries.emplace(ToCacheAddr(host_ptr)); + } + auto& memory_manager = Core::System::GetInstance().GPU().MemoryManager(); + const auto cpu_addr = *memory_manager.GpuToCpuAddress(gpu_addr); + auto entry = GetUncachedBuffer(cpu_addr, host_ptr); + entry->SetSize(size); + entry->SetInternalState(internalize); + Register(entry); + + if (entry->GetCapacity() < size) { + entry->SetCapacity(CreateBuffer(size, GL_STATIC_DRAW), size); + } + glNamedBufferSubData(entry->GetBuffer(), 0, static_cast(size), host_ptr); + return {entry->GetBuffer(), CachedBufferOffset}; +} + +void OGLBufferCache::GrowBuffer(std::shared_ptr& entry, std::size_t new_size) { + const auto old_size = static_cast(entry->GetSize()); + if (entry->GetCapacity() < new_size) { + const auto old_buffer = entry->GetBuffer(); + OGLBuffer new_buffer = CreateBuffer(new_size, GL_STATIC_COPY); - if (invalidate) { - InvalidateAll(); + // Copy bits from the old buffer to the new buffer. + glCopyNamedBufferSubData(old_buffer, new_buffer.handle, 0, 0, old_size); + entry->SetCapacity(std::move(new_buffer), new_size); } - return invalidate; + // Upload the new bits. + const auto size_diff = static_cast(new_size - old_size); + glNamedBufferSubData(entry->GetBuffer(), old_size, size_diff, entry->GetHostPtr() + old_size); + + // Update entry's size in the object and in the cache. + entry->SetSize(new_size); + Unregister(entry); + Register(entry); } -void OGLBufferCache::Unmap() { - stream_buffer.Unmap(buffer_offset - buffer_offset_base); +std::shared_ptr OGLBufferCache::GetUncachedBuffer(VAddr cpu_addr, u8* host_ptr) { + if (auto entry = TryGetReservedBuffer(host_ptr); entry) { + return entry; + } + return std::make_shared(cpu_addr, host_ptr); +} + +std::shared_ptr OGLBufferCache::TryGetReservedBuffer(u8* host_ptr) { + const auto it = buffer_reserve.find(ToCacheAddr(host_ptr)); + if (it == buffer_reserve.end()) { + return {}; + } + auto& reserve = it->second; + auto entry = reserve.back(); + reserve.pop_back(); + return entry; +} + +void OGLBufferCache::ReserveBuffer(std::shared_ptr entry) { + buffer_reserve[entry->GetCacheAddr()].push_back(std::move(entry)); } void OGLBufferCache::AlignBuffer(std::size_t alignment) { -- cgit v1.2.3