yuzu-emu
/
yuzu-android
Archived
1
0
Fork 0
Code

video_core: memory_manager: Use GPU interface for cache functions.

This commit is contained in:
bunnei 2020-02-01 21:01:00 -05:00
parent 90bda66028
commit 7cacb08cdf
3 changed files with 9 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/video_core/gpu.cpp
View File

@ -23,7 +23,7 @@ MICROPROFILE_DEFINE(GPU_wait, "GPU", "Wait for the GPU", MP_RGB(128, 128, 192));
GPU::GPU(Core::System& system, VideoCore::RendererBase& renderer, bool is_async) GPU::GPU(Core::System& system, VideoCore::RendererBase& renderer, bool is_async)
: system{system}, renderer{renderer}, is_async{is_async} { : system{system}, renderer{renderer}, is_async{is_async} {
auto& rasterizer{renderer.Rasterizer()}; auto& rasterizer{renderer.Rasterizer()};
memory_manager = std::make_unique<Tegra::MemoryManager>(system, rasterizer); memory_manager = std::make_unique<Tegra::MemoryManager>(system);
dma_pusher = std::make_unique<Tegra::DmaPusher>(*this); dma_pusher = std::make_unique<Tegra::DmaPusher>(*this);
maxwell_3d = std::make_unique<Engines::Maxwell3D>(system, rasterizer, *memory_manager); maxwell_3d = std::make_unique<Engines::Maxwell3D>(system, rasterizer, *memory_manager);
fermi_2d = std::make_unique<Engines::Fermi2D>(rasterizer); fermi_2d = std::make_unique<Engines::Fermi2D>(rasterizer);

14
src/video_core/memory_manager.cpp
View File

@ -9,13 +9,12 @@
#include "core/hle/kernel/process.h" #include "core/hle/kernel/process.h"
#include "core/hle/kernel/vm_manager.h" #include "core/hle/kernel/vm_manager.h"
#include "core/memory.h" #include "core/memory.h"
#include "video_core/gpu.h"
#include "video_core/memory_manager.h" #include "video_core/memory_manager.h"
#include "video_core/rasterizer_interface.h"
namespace Tegra { namespace Tegra {
MemoryManager::MemoryManager(Core::System& system, VideoCore::RasterizerInterface& rasterizer) MemoryManager::MemoryManager(Core::System& system) : system{system} {
: rasterizer{rasterizer}, system{system} {
std::fill(page_table.pointers.begin(), page_table.pointers.end(), nullptr); std::fill(page_table.pointers.begin(), page_table.pointers.end(), nullptr);
std::fill(page_table.attributes.begin(), page_table.attributes.end(), std::fill(page_table.attributes.begin(), page_table.attributes.end(),
Common::PageType::Unmapped); Common::PageType::Unmapped);
@ -84,7 +83,8 @@ GPUVAddr MemoryManager::UnmapBuffer(GPUVAddr gpu_addr, u64 size) {
const auto cpu_addr = GpuToCpuAddress(gpu_addr); const auto cpu_addr = GpuToCpuAddress(gpu_addr);
ASSERT(cpu_addr); ASSERT(cpu_addr);
rasterizer.FlushAndInvalidateRegion(cache_addr, aligned_size); system.GPU().FlushAndInvalidateRegion(cache_addr, aligned_size);
UnmapRange(gpu_addr, aligned_size); UnmapRange(gpu_addr, aligned_size);
ASSERT(system.CurrentProcess() ASSERT(system.CurrentProcess()
->VMManager() ->VMManager()
@ -242,7 +242,7 @@ void MemoryManager::ReadBlock(GPUVAddr src_addr, void* dest_buffer, const std::s
switch (page_table.attributes[page_index]) { switch (page_table.attributes[page_index]) {
case Common::PageType::Memory: { case Common::PageType::Memory: {
const u8* src_ptr{page_table.pointers[page_index] + page_offset}; const u8* src_ptr{page_table.pointers[page_index] + page_offset};
rasterizer.FlushRegion(ToCacheAddr(src_ptr), copy_amount); system.GPU().FlushRegion(ToCacheAddr(src_ptr), copy_amount);
std::memcpy(dest_buffer, src_ptr, copy_amount); std::memcpy(dest_buffer, src_ptr, copy_amount);
break; break;
} }
@ -292,7 +292,7 @@ void MemoryManager::WriteBlock(GPUVAddr dest_addr, const void* src_buffer, const
switch (page_table.attributes[page_index]) { switch (page_table.attributes[page_index]) {
case Common::PageType::Memory: { case Common::PageType::Memory: {
u8* dest_ptr{page_table.pointers[page_index] + page_offset}; u8* dest_ptr{page_table.pointers[page_index] + page_offset};
rasterizer.InvalidateRegion(ToCacheAddr(dest_ptr), copy_amount); system.GPU().InvalidateRegion(ToCacheAddr(dest_ptr), copy_amount);
std::memcpy(dest_ptr, src_buffer, copy_amount); std::memcpy(dest_ptr, src_buffer, copy_amount);
break; break;
} }
@ -340,7 +340,7 @@ void MemoryManager::CopyBlock(GPUVAddr dest_addr, GPUVAddr src_addr, const std::
switch (page_table.attributes[page_index]) { switch (page_table.attributes[page_index]) {
case Common::PageType::Memory: { case Common::PageType::Memory: {
const u8* src_ptr{page_table.pointers[page_index] + page_offset}; const u8* src_ptr{page_table.pointers[page_index] + page_offset};
rasterizer.FlushRegion(ToCacheAddr(src_ptr), copy_amount); system.GPU().FlushRegion(ToCacheAddr(src_ptr), copy_amount);
WriteBlock(dest_addr, src_ptr, copy_amount); WriteBlock(dest_addr, src_ptr, copy_amount);
break; break;
} }

7
src/video_core/memory_manager.h
View File

@ -10,10 +10,6 @@
#include "common/common_types.h" #include "common/common_types.h"
#include "common/page_table.h" #include "common/page_table.h"
namespace VideoCore {
class RasterizerInterface;
}
namespace Core { namespace Core {
class System; class System;
} }
@ -51,7 +47,7 @@ struct VirtualMemoryArea {
class MemoryManager final { class MemoryManager final {
public: public:
explicit MemoryManager(Core::System& system, VideoCore::RasterizerInterface& rasterizer); explicit MemoryManager(Core::System& system);
~MemoryManager(); ~MemoryManager();
GPUVAddr AllocateSpace(u64 size, u64 align); GPUVAddr AllocateSpace(u64 size, u64 align);
@ -176,7 +172,6 @@ private:
Common::PageTable page_table{page_bits}; Common::PageTable page_table{page_bits};
VMAMap vma_map; VMAMap vma_map;
VideoCore::RasterizerInterface& rasterizer;
Core::System& system; Core::System& system;
}; };