From 4c2ed2706e3579ec1304907dad0d45673768e1fc Mon Sep 17 00:00:00 2001 From: Lioncash Date: Tue, 26 Nov 2019 12:33:20 -0500 Subject: core/memory: Introduce skeleton of Memory class Currently, the main memory management code is one of the remaining places where we have global state. The next series of changes will aim to rectify this. This change simply introduces the main skeleton of the class that will contain all the necessary state. --- src/core/core.cpp | 16 +++++++++++++--- src/core/core.h | 10 ++++++++++ src/core/memory.cpp | 12 ++++++++++++ src/core/memory.h | 21 +++++++++++++++++++++ 4 files changed, 56 insertions(+), 3 deletions(-) (limited to 'src/core') diff --git a/src/core/core.cpp b/src/core/core.cpp index eba17218a..c45fb960c 100644 --- a/src/core/core.cpp +++ b/src/core/core.cpp @@ -39,6 +39,7 @@ #include "core/hle/service/service.h" #include "core/hle/service/sm/sm.h" #include "core/loader/loader.h" +#include "core/memory.h" #include "core/memory/cheat_engine.h" #include "core/perf_stats.h" #include "core/reporter.h" @@ -112,8 +113,8 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs, } struct System::Impl { explicit Impl(System& system) - : kernel{system}, fs_controller{system}, cpu_core_manager{system}, reporter{system}, - applet_manager{system} {} + : kernel{system}, fs_controller{system}, memory{system}, + cpu_core_manager{system}, reporter{system}, applet_manager{system} {} Cpu& CurrentCpuCore() { return cpu_core_manager.GetCurrentCore(); @@ -341,7 +342,8 @@ struct System::Impl { std::unique_ptr renderer; std::unique_ptr gpu_core; std::shared_ptr debug_context; - std::unique_ptr interrupt_manager; + std::unique_ptr interrupt_manager; + Memory::Memory memory; CpuCoreManager cpu_core_manager; bool is_powered_on = false; bool exit_lock = false; @@ -498,6 +500,14 @@ const ExclusiveMonitor& System::Monitor() const { return impl->cpu_core_manager.GetExclusiveMonitor(); } +Memory::Memory& System::Memory() { + return impl->memory; +} + +const Memory::Memory& System::Memory() const { + return impl->memory; +} + Tegra::GPU& System::GPU() { return *impl->gpu_core; } diff --git a/src/core/core.h b/src/core/core.h index f9b1a2866..91184e433 100644 --- a/src/core/core.h +++ b/src/core/core.h @@ -86,6 +86,10 @@ namespace Core::Hardware { class InterruptManager; } +namespace Memory { +class Memory; +} + namespace Core { class ARM_Interface; @@ -225,6 +229,12 @@ public: /// Gets a constant reference to the exclusive monitor const ExclusiveMonitor& Monitor() const; + /// Gets a mutable reference to the system memory instance. + Memory::Memory& Memory(); + + /// Gets a constant reference to the system memory instance. + const Memory::Memory& Memory() const; + /// Gets a mutable reference to the GPU interface Tegra::GPU& GPU(); diff --git a/src/core/memory.cpp b/src/core/memory.cpp index fa49f3dd0..2098f13f7 100644 --- a/src/core/memory.cpp +++ b/src/core/memory.cpp @@ -24,6 +24,18 @@ namespace Memory { static Common::PageTable* current_page_table = nullptr; +// Implementation class used to keep the specifics of the memory subsystem hidden +// from outside classes. This also allows modification to the internals of the memory +// subsystem without needing to rebuild all files that make use of the memory interface. +struct Memory::Impl { + explicit Impl(Core::System& system_) : system{system_} {} + + Core::System& system; +}; + +Memory::Memory(Core::System& system) : impl{std::make_unique(system)} {} +Memory::~Memory() = default; + void SetCurrentPageTable(Kernel::Process& process) { current_page_table = &process.VMManager().page_table; diff --git a/src/core/memory.h b/src/core/memory.h index 09008e1dd..c690df3c3 100644 --- a/src/core/memory.h +++ b/src/core/memory.h @@ -8,6 +8,10 @@ #include #include "common/common_types.h" +namespace Core { +class System; +} + namespace Kernel { class Process; } @@ -36,6 +40,23 @@ enum : VAddr { KERNEL_REGION_END = KERNEL_REGION_VADDR + KERNEL_REGION_SIZE, }; +/// Central class that handles all memory operations and state. +class Memory { +public: + explicit Memory(Core::System& system); + ~Memory(); + + Memory(const Memory&) = delete; + Memory& operator=(const Memory&) = delete; + + Memory(Memory&&) = default; + Memory& operator=(Memory&&) = default; + +private: + struct Impl; + std::unique_ptr impl; +}; + /// Changes the currently active page table to that of /// the given process instance. void SetCurrentPageTable(Kernel::Process& process); -- cgit v1.2.3