mirrors/yuzu
2
1
Fork 0
mirror of https://github.com/yuzu-emu/yuzu.git synced 2024-07-04 23:31:19 +01:00
Code Issues Releases Activity

gl_buffer_cache: Store in CachedBufferEntry the used buffer handle

Browse source
This commit is contained in:
ReinUsesLisp 2019-05-27 20:11:46 -03:00
parent b54fb8fc4c
commit f8ba72d491
2 changed files with 30 additions and 23 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
src/video_core/renderer_opengl/gl_buffer_cache.cpp
View file

@ -14,10 +14,10 @@
namespace OpenGL {
CachedBufferEntry::CachedBufferEntry(VAddr cpu_addr, std::size_t size, GLintptr offset,
std::size_t alignment, u8* host_ptr)
: RasterizerCacheObject{host_ptr}, cpu_addr{cpu_addr}, size{size}, offset{offset},
alignment{alignment} {}
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} {}
OGLBufferCache::OGLBufferCache(RasterizerOpenGL& rasterizer, std::size_t size)
: RasterizerCache{rasterizer}, stream_buffer(size, true) {}
@ -28,16 +28,20 @@ std::pair<GLuint, GLintptr> OGLBufferCache::UploadMemory(GPUVAddr gpu_addr, std:
auto& memory_manager = Core::System::GetInstance().GPU().MemoryManager();
const auto& host_ptr{memory_manager.GetPointer(gpu_addr)};
if (!host_ptr) {
// Return a dummy buffer when host_ptr is invalid.
return {0, 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;
const auto& host_ptr{memory_manager.GetPointer(gpu_addr)};
if (cache) {
auto entry = TryGet(host_ptr);
if (entry) {
if (auto entry = TryGet(host_ptr); entry) {
if (entry->GetSize() >= size && entry->GetAlignment() == alignment) {
return {stream_buffer.GetHandle(), entry->GetOffset()};
return {entry->GetBuffer(), entry->GetOffset()};
}
Unregister(entry);
}
@ -46,21 +50,18 @@ std::pair<GLuint, GLintptr> OGLBufferCache::UploadMemory(GPUVAddr gpu_addr, std:
AlignBuffer(alignment);
const GLintptr uploaded_offset = buffer_offset;
if (!host_ptr) {
return {stream_buffer.GetHandle(), uploaded_offset};
}
std::memcpy(buffer_ptr, host_ptr, size);
buffer_ptr += size;
buffer_offset += size;
const GLuint buffer = stream_buffer.GetHandle();
if (cache) {
auto entry = std::make_shared<CachedBufferEntry>(
*memory_manager.GpuToCpuAddress(gpu_addr), size, uploaded_offset, alignment, host_ptr);
Register(entry);
const VAddr cpu_addr = *memory_manager.GpuToCpuAddress(gpu_addr);
Register(std::make_shared<CachedBufferEntry>(cpu_addr, host_ptr, size, alignment, buffer,
uploaded_offset));
}
return {stream_buffer.GetHandle(), uploaded_offset};
return {buffer, uploaded_offset};
}
std::pair<GLuint, GLintptr> OGLBufferCache::UploadHostMemory(const void* raw_pointer,

20
src/video_core/renderer_opengl/gl_buffer_cache.h
View file

@ -20,8 +20,8 @@ class RasterizerOpenGL;
class CachedBufferEntry final : public RasterizerCacheObject {
public:
explicit CachedBufferEntry(VAddr cpu_addr, std::size_t size, GLintptr offset,
std::size_t alignment, u8* host_ptr);
explicit CachedBufferEntry(VAddr cpu_addr, u8* host_ptr, std::size_t size,
std::size_t alignment, GLuint buffer, GLintptr offset);
VAddr GetCpuAddr() const override {
return cpu_addr;
@ -35,19 +35,25 @@ public:
return size;
}
GLintptr GetOffset() const {
return offset;
}
std::size_t GetAlignment() const {
return alignment;
}
GLuint GetBuffer() const {
return buffer;
}
GLintptr GetOffset() const {
return offset;
}
private:
VAddr cpu_addr{};
std::size_t size{};
GLintptr offset{};
std::size_t alignment{};
GLuint buffer{};
GLintptr offset{};
};
class OGLBufferCache final : public RasterizerCache<std::shared_ptr<CachedBufferEntry>> {