kernel/scheduler: Pass in system instance in constructor

Avoids directly relying on the global system instance and instead makes an arbitrary system instance an explicit dependency on construction. This also allows removing dependencies on some global accessor functions as well.
2019-03-04 17:01:37 -05:00
75 changed files with 693 additions and 1361 deletions
@@ -217,7 +217,6 @@ add_library(core STATIC
    hle/service/audio/audren_u.h
    hle/service/audio/codecctl.cpp
    hle/service/audio/codecctl.h
-    hle/service/audio/errors.h
    hle/service/audio/hwopus.cpp
    hle/service/audio/hwopus.h
    hle/service/bcat/bcat.cpp
@@ -36,8 +36,7 @@
 #include "frontend/applets/software_keyboard.h"
 #include "frontend/applets/web_browser.h"
 #include "video_core/debug_utils/debug_utils.h"
-#include "video_core/gpu_asynch.h"
-#include "video_core/gpu_synch.h"
+#include "video_core/gpu.h"
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"

@@ -79,7 +78,6 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
    return vfs->OpenFile(path, FileSys::Mode::Read);
 }
 struct System::Impl {
-    explicit Impl(System& system) : kernel{system} {}

    Cpu& CurrentCpuCore() {
        return cpu_core_manager.GetCurrentCore();
@@ -97,7 +95,7 @@ struct System::Impl {
        LOG_DEBUG(HW_Memory, "initialized OK");

        core_timing.Initialize();
-        kernel.Initialize();
+        kernel.Initialize(core_timing);

        const auto current_time = std::chrono::duration_cast<std::chrono::seconds>(
            std::chrono::system_clock::now().time_since_epoch());
@@ -130,16 +128,10 @@ struct System::Impl {
            return ResultStatus::ErrorVideoCore;
        }

-        is_powered_on = true;
-
-        if (Settings::values.use_asynchronous_gpu_emulation) {
-            gpu_core = std::make_unique<VideoCommon::GPUAsynch>(system, *renderer);
-        } else {
-            gpu_core = std::make_unique<VideoCommon::GPUSynch>(system, *renderer);
-        }
+        gpu_core = std::make_unique<Tegra::GPU>(system, renderer->Rasterizer());

        cpu_core_manager.Initialize(system);
-
+        is_powered_on = true;
        LOG_DEBUG(Core, "Initialized OK");

        // Reset counters and set time origin to current frame
@@ -190,13 +182,13 @@ struct System::Impl {

    void Shutdown() {
        // Log last frame performance stats
-        const auto perf_results = GetAndResetPerfStats();
-        telemetry_session->AddField(Telemetry::FieldType::Performance, "Shutdown_EmulationSpeed",
-                                    perf_results.emulation_speed * 100.0);
-        telemetry_session->AddField(Telemetry::FieldType::Performance, "Shutdown_Framerate",
-                                    perf_results.game_fps);
-        telemetry_session->AddField(Telemetry::FieldType::Performance, "Shutdown_Frametime",
-                                    perf_results.frametime * 1000.0);
+        auto perf_results = GetAndResetPerfStats();
+        Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_EmulationSpeed",
+                             perf_results.emulation_speed * 100.0);
+        Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_Framerate",
+                             perf_results.game_fps);
+        Telemetry().AddField(Telemetry::FieldType::Performance, "Shutdown_Frametime",
+                             perf_results.frametime * 1000.0);

        is_powered_on = false;

@@ -273,7 +265,7 @@ struct System::Impl {
    Core::FrameLimiter frame_limiter;
 };

-System::System() : impl{std::make_unique<Impl>(*this)} {}
+System::System() : impl{std::make_unique<Impl>()} {}
 System::~System() = default;

 Cpu& System::CurrentCpuCore() {
@@ -293,6 +293,10 @@ inline ARM_Interface& CurrentArmInterface() {
    return System::GetInstance().CurrentArmInterface();
 }

+inline TelemetrySession& Telemetry() {
+    return System::GetInstance().TelemetrySession();
+}
+
 inline Kernel::Process* CurrentProcess() {
    return System::GetInstance().CurrentProcess();
 }
@@ -11,6 +11,7 @@
 #endif
 #include "core/arm/exclusive_monitor.h"
 #include "core/arm/unicorn/arm_unicorn.h"
+#include "core/core.h"
 #include "core/core_cpu.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/scheduler.h"
@@ -49,9 +50,9 @@ bool CpuBarrier::Rendezvous() {
    return false;
 }

-Cpu::Cpu(Timing::CoreTiming& core_timing, ExclusiveMonitor& exclusive_monitor,
-         CpuBarrier& cpu_barrier, std::size_t core_index)
-    : cpu_barrier{cpu_barrier}, core_timing{core_timing}, core_index{core_index} {
+Cpu::Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier,
+         std::size_t core_index)
+    : cpu_barrier{cpu_barrier}, core_timing{system.CoreTiming()}, core_index{core_index} {
    if (Settings::values.use_cpu_jit) {
 #ifdef ARCHITECTURE_x86_64
        arm_interface = std::make_unique<ARM_Dynarmic>(core_timing, exclusive_monitor, core_index);
@@ -63,7 +64,7 @@ Cpu::Cpu(Timing::CoreTiming& core_timing, ExclusiveMonitor& exclusive_monitor,
        arm_interface = std::make_unique<ARM_Unicorn>(core_timing);
    }

-    scheduler = std::make_unique<Kernel::Scheduler>(*arm_interface);
+    scheduler = std::make_unique<Kernel::Scheduler>(system, *arm_interface);
 }

 Cpu::~Cpu() = default;
@@ -15,6 +15,10 @@ namespace Kernel {
 class Scheduler;
 }

+namespace Core {
+class System;
+}
+
 namespace Core::Timing {
 class CoreTiming;
 }
@@ -45,8 +49,8 @@ private:

 class Cpu {
 public:
-    Cpu(Timing::CoreTiming& core_timing, ExclusiveMonitor& exclusive_monitor,
-        CpuBarrier& cpu_barrier, std::size_t core_index);
+    Cpu(System& system, ExclusiveMonitor& exclusive_monitor, CpuBarrier& cpu_barrier,
+        std::size_t core_index);
    ~Cpu();

    void RunLoop(bool tight_loop = true);
@@ -27,8 +27,7 @@ void CpuCoreManager::Initialize(System& system) {
    exclusive_monitor = Cpu::MakeExclusiveMonitor(cores.size());

    for (std::size_t index = 0; index < cores.size(); ++index) {
-        cores[index] =
-            std::make_unique<Cpu>(system.CoreTiming(), *exclusive_monitor, *barrier, index);
+        cores[index] = std::make_unique<Cpu>(system, *exclusive_monitor, *barrier, index);
    }

    // Create threads for CPU cores 1-3, and build thread_to_cpu map
@@ -4,10 +4,10 @@

 #pragma once

-#include "common/bit_field.h"
-#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
+#include "core/hle/kernel/errors.h"
+#include "core/memory.h"

 namespace IPC {

@@ -9,7 +9,6 @@
 #include "common/common_types.h"
 #include "core/core.h"
 #include "core/core_cpu.h"
-#include "core/hle/kernel/address_arbiter.h"
 #include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/object.h"
 #include "core/hle/kernel/process.h"
@@ -18,144 +17,32 @@
 #include "core/hle/result.h"
 #include "core/memory.h"

-namespace Kernel {
-namespace {
-// Wake up num_to_wake (or all) threads in a vector.
-void WakeThreads(const std::vector<SharedPtr<Thread>>& waiting_threads, s32 num_to_wake) {
-    // Only process up to 'target' threads, unless 'target' is <= 0, in which case process
-    // them all.
-    std::size_t last = waiting_threads.size();
-    if (num_to_wake > 0) {
-        last = num_to_wake;
-    }
+namespace Kernel::AddressArbiter {

-    // Signal the waiting threads.
-    for (std::size_t i = 0; i < last; i++) {
-        ASSERT(waiting_threads[i]->GetStatus() == ThreadStatus::WaitArb);
-        waiting_threads[i]->SetWaitSynchronizationResult(RESULT_SUCCESS);
-        waiting_threads[i]->SetArbiterWaitAddress(0);
-        waiting_threads[i]->ResumeFromWait();
-    }
-}
-} // Anonymous namespace
-
-AddressArbiter::AddressArbiter(Core::System& system) : system{system} {}
-AddressArbiter::~AddressArbiter() = default;
-
-ResultCode AddressArbiter::SignalToAddress(VAddr address, s32 num_to_wake) {
-    const std::vector<SharedPtr<Thread>> waiting_threads = GetThreadsWaitingOnAddress(address);
-    WakeThreads(waiting_threads, num_to_wake);
-    return RESULT_SUCCESS;
-}
-
-ResultCode AddressArbiter::IncrementAndSignalToAddressIfEqual(VAddr address, s32 value,
-                                                              s32 num_to_wake) {
-    // Ensure that we can write to the address.
-    if (!Memory::IsValidVirtualAddress(address)) {
-        return ERR_INVALID_ADDRESS_STATE;
-    }
-
-    if (static_cast<s32>(Memory::Read32(address)) != value) {
-        return ERR_INVALID_STATE;
-    }
-
-    Memory::Write32(address, static_cast<u32>(value + 1));
-    return SignalToAddress(address, num_to_wake);
-}
-
-ResultCode AddressArbiter::ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 value,
-                                                                         s32 num_to_wake) {
-    // Ensure that we can write to the address.
-    if (!Memory::IsValidVirtualAddress(address)) {
-        return ERR_INVALID_ADDRESS_STATE;
-    }
-
-    // Get threads waiting on the address.
-    const std::vector<SharedPtr<Thread>> waiting_threads = GetThreadsWaitingOnAddress(address);
-
-    // Determine the modified value depending on the waiting count.
-    s32 updated_value;
-    if (waiting_threads.empty()) {
-        updated_value = value - 1;
-    } else if (num_to_wake <= 0 || waiting_threads.size() <= static_cast<u32>(num_to_wake)) {
-        updated_value = value + 1;
-    } else {
-        updated_value = value;
-    }
-
-    if (static_cast<s32>(Memory::Read32(address)) != value) {
-        return ERR_INVALID_STATE;
-    }
-
-    Memory::Write32(address, static_cast<u32>(updated_value));
-    WakeThreads(waiting_threads, num_to_wake);
-    return RESULT_SUCCESS;
-}
-
-ResultCode AddressArbiter::WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout,
-                                                    bool should_decrement) {
-    // Ensure that we can read the address.
-    if (!Memory::IsValidVirtualAddress(address)) {
-        return ERR_INVALID_ADDRESS_STATE;
-    }
-
-    const s32 cur_value = static_cast<s32>(Memory::Read32(address));
-    if (cur_value >= value) {
-        return ERR_INVALID_STATE;
-    }
-
-    if (should_decrement) {
-        Memory::Write32(address, static_cast<u32>(cur_value - 1));
-    }
-
-    // Short-circuit without rescheduling, if timeout is zero.
-    if (timeout == 0) {
-        return RESULT_TIMEOUT;
-    }
-
-    return WaitForAddress(address, timeout);
-}
-
-ResultCode AddressArbiter::WaitForAddressIfEqual(VAddr address, s32 value, s64 timeout) {
-    // Ensure that we can read the address.
-    if (!Memory::IsValidVirtualAddress(address)) {
-        return ERR_INVALID_ADDRESS_STATE;
-    }
-    // Only wait for the address if equal.
-    if (static_cast<s32>(Memory::Read32(address)) != value) {
-        return ERR_INVALID_STATE;
-    }
-    // Short-circuit without rescheduling, if timeout is zero.
-    if (timeout == 0) {
-        return RESULT_TIMEOUT;
-    }
-
-    return WaitForAddress(address, timeout);
-}
-
-ResultCode AddressArbiter::WaitForAddress(VAddr address, s64 timeout) {
-    SharedPtr<Thread> current_thread = system.CurrentScheduler().GetCurrentThread();
+// Performs actual address waiting logic.
+static ResultCode WaitForAddress(VAddr address, s64 timeout) {
+    SharedPtr<Thread> current_thread = GetCurrentThread();
    current_thread->SetArbiterWaitAddress(address);
    current_thread->SetStatus(ThreadStatus::WaitArb);
    current_thread->InvalidateWakeupCallback();

    current_thread->WakeAfterDelay(timeout);

-    system.CpuCore(current_thread->GetProcessorID()).PrepareReschedule();
+    Core::System::GetInstance().CpuCore(current_thread->GetProcessorID()).PrepareReschedule();
    return RESULT_TIMEOUT;
 }

-std::vector<SharedPtr<Thread>> AddressArbiter::GetThreadsWaitingOnAddress(VAddr address) const {
-    const auto RetrieveWaitingThreads = [this](std::size_t core_index,
-                                               std::vector<SharedPtr<Thread>>& waiting_threads,
-                                               VAddr arb_addr) {
-        const auto& scheduler = system.Scheduler(core_index);
+// Gets the threads waiting on an address.
+static std::vector<SharedPtr<Thread>> GetThreadsWaitingOnAddress(VAddr address) {
+    const auto RetrieveWaitingThreads = [](std::size_t core_index,
+                                           std::vector<SharedPtr<Thread>>& waiting_threads,
+                                           VAddr arb_addr) {
+        const auto& scheduler = Core::System::GetInstance().Scheduler(core_index);
        const auto& thread_list = scheduler.GetThreadList();

        for (const auto& thread : thread_list) {
-            if (thread->GetArbiterWaitAddress() == arb_addr) {
+            if (thread->GetArbiterWaitAddress() == arb_addr)
                waiting_threads.push_back(thread);
-            }
        }
    };

@@ -174,4 +61,118 @@ std::vector<SharedPtr<Thread>> AddressArbiter::GetThreadsWaitingOnAddress(VAddr

    return threads;
 }
-} // namespace Kernel
+
+// Wake up num_to_wake (or all) threads in a vector.
+static void WakeThreads(std::vector<SharedPtr<Thread>>& waiting_threads, s32 num_to_wake) {
+    // Only process up to 'target' threads, unless 'target' is <= 0, in which case process
+    // them all.
+    std::size_t last = waiting_threads.size();
+    if (num_to_wake > 0)
+        last = num_to_wake;
+
+    // Signal the waiting threads.
+    for (std::size_t i = 0; i < last; i++) {
+        ASSERT(waiting_threads[i]->GetStatus() == ThreadStatus::WaitArb);
+        waiting_threads[i]->SetWaitSynchronizationResult(RESULT_SUCCESS);
+        waiting_threads[i]->SetArbiterWaitAddress(0);
+        waiting_threads[i]->ResumeFromWait();
+    }
+}
+
+// Signals an address being waited on.
+ResultCode SignalToAddress(VAddr address, s32 num_to_wake) {
+    std::vector<SharedPtr<Thread>> waiting_threads = GetThreadsWaitingOnAddress(address);
+
+    WakeThreads(waiting_threads, num_to_wake);
+    return RESULT_SUCCESS;
+}
+
+// Signals an address being waited on and increments its value if equal to the value argument.
+ResultCode IncrementAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake) {
+    // Ensure that we can write to the address.
+    if (!Memory::IsValidVirtualAddress(address)) {
+        return ERR_INVALID_ADDRESS_STATE;
+    }
+
+    if (static_cast<s32>(Memory::Read32(address)) == value) {
+        Memory::Write32(address, static_cast<u32>(value + 1));
+    } else {
+        return ERR_INVALID_STATE;
+    }
+
+    return SignalToAddress(address, num_to_wake);
+}
+
+// Signals an address being waited on and modifies its value based on waiting thread count if equal
+// to the value argument.
+ResultCode ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 value,
+                                                         s32 num_to_wake) {
+    // Ensure that we can write to the address.
+    if (!Memory::IsValidVirtualAddress(address)) {
+        return ERR_INVALID_ADDRESS_STATE;
+    }
+
+    // Get threads waiting on the address.
+    std::vector<SharedPtr<Thread>> waiting_threads = GetThreadsWaitingOnAddress(address);
+
+    // Determine the modified value depending on the waiting count.
+    s32 updated_value;
+    if (waiting_threads.empty()) {
+        updated_value = value - 1;
+    } else if (num_to_wake <= 0 || waiting_threads.size() <= static_cast<u32>(num_to_wake)) {
+        updated_value = value + 1;
+    } else {
+        updated_value = value;
+    }
+
+    if (static_cast<s32>(Memory::Read32(address)) == value) {
+        Memory::Write32(address, static_cast<u32>(updated_value));
+    } else {
+        return ERR_INVALID_STATE;
+    }
+
+    WakeThreads(waiting_threads, num_to_wake);
+    return RESULT_SUCCESS;
+}
+
+// Waits on an address if the value passed is less than the argument value, optionally decrementing.
+ResultCode WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout, bool should_decrement) {
+    // Ensure that we can read the address.
+    if (!Memory::IsValidVirtualAddress(address)) {
+        return ERR_INVALID_ADDRESS_STATE;
+    }
+
+    s32 cur_value = static_cast<s32>(Memory::Read32(address));
+    if (cur_value < value) {
+        if (should_decrement) {
+            Memory::Write32(address, static_cast<u32>(cur_value - 1));
+        }
+    } else {
+        return ERR_INVALID_STATE;
+    }
+    // Short-circuit without rescheduling, if timeout is zero.
+    if (timeout == 0) {
+        return RESULT_TIMEOUT;
+    }
+
+    return WaitForAddress(address, timeout);
+}
+
+// Waits on an address if the value passed is equal to the argument value.
+ResultCode WaitForAddressIfEqual(VAddr address, s32 value, s64 timeout) {
+    // Ensure that we can read the address.
+    if (!Memory::IsValidVirtualAddress(address)) {
+        return ERR_INVALID_ADDRESS_STATE;
+    }
+    // Only wait for the address if equal.
+    if (static_cast<s32>(Memory::Read32(address)) != value) {
+        return ERR_INVALID_STATE;
+    }
+    // Short-circuit without rescheduling, if timeout is zero.
+    if (timeout == 0) {
+        return RESULT_TIMEOUT;
+    }
+
+    return WaitForAddress(address, timeout);
+}
+} // namespace Kernel::AddressArbiter
@@ -5,68 +5,28 @@
 #pragma once

 #include "common/common_types.h"
-#include "core/hle/kernel/address_arbiter.h"

 union ResultCode;

-namespace Core {
-class System;
-}
+namespace Kernel::AddressArbiter {

-namespace Kernel {
-
-class Thread;
-
-class AddressArbiter {
-public:
-    enum class ArbitrationType {
-        WaitIfLessThan = 0,
-        DecrementAndWaitIfLessThan = 1,
-        WaitIfEqual = 2,
-    };
-
-    enum class SignalType {
-        Signal = 0,
-        IncrementAndSignalIfEqual = 1,
-        ModifyByWaitingCountAndSignalIfEqual = 2,
-    };
-
-    explicit AddressArbiter(Core::System& system);
-    ~AddressArbiter();
-
-    AddressArbiter(const AddressArbiter&) = delete;
-    AddressArbiter& operator=(const AddressArbiter&) = delete;
-
-    AddressArbiter(AddressArbiter&&) = default;
-    AddressArbiter& operator=(AddressArbiter&&) = delete;
-
-    /// Signals an address being waited on.
-    ResultCode SignalToAddress(VAddr address, s32 num_to_wake);
-
-    /// Signals an address being waited on and increments its value if equal to the value argument.
-    ResultCode IncrementAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake);
-
-    /// Signals an address being waited on and modifies its value based on waiting thread count if
-    /// equal to the value argument.
-    ResultCode ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 value,
-                                                             s32 num_to_wake);
-
-    /// Waits on an address if the value passed is less than the argument value,
-    /// optionally decrementing.
-    ResultCode WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout,
-                                        bool should_decrement);
-
-    /// Waits on an address if the value passed is equal to the argument value.
-    ResultCode WaitForAddressIfEqual(VAddr address, s32 value, s64 timeout);
-
-private:
-    // Waits on the given address with a timeout in nanoseconds
-    ResultCode WaitForAddress(VAddr address, s64 timeout);
-
-    // Gets the threads waiting on an address.
-    std::vector<SharedPtr<Thread>> GetThreadsWaitingOnAddress(VAddr address) const;
-
-    Core::System& system;
+enum class ArbitrationType {
+    WaitIfLessThan = 0,
+    DecrementAndWaitIfLessThan = 1,
+    WaitIfEqual = 2,
 };

-} // namespace Kernel
+enum class SignalType {
+    Signal = 0,
+    IncrementAndSignalIfEqual = 1,
+    ModifyByWaitingCountAndSignalIfEqual = 2,
+};
+
+ResultCode SignalToAddress(VAddr address, s32 num_to_wake);
+ResultCode IncrementAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake);
+ResultCode ModifyByWaitingCountAndSignalToAddressIfEqual(VAddr address, s32 value, s32 num_to_wake);
+
+ResultCode WaitForAddressIfLessThan(VAddr address, s32 value, s64 timeout, bool should_decrement);
+ResultCode WaitForAddressIfEqual(VAddr address, s32 value, s64 timeout);
+
+} // namespace Kernel::AddressArbiter
@@ -15,8 +15,6 @@
 #include "core/hle/ipc.h"
 #include "core/hle/kernel/object.h"

-union ResultCode;
-
 namespace Service {
 class ServiceFrameworkBase;
 }
@@ -210,12 +208,14 @@ public:

    template <typename T>
    SharedPtr<T> GetCopyObject(std::size_t index) {
-        return DynamicObjectCast<T>(copy_objects.at(index));
+        ASSERT(index < copy_objects.size());
+        return DynamicObjectCast<T>(copy_objects[index]);
    }

    template <typename T>
    SharedPtr<T> GetMoveObject(std::size_t index) {
-        return DynamicObjectCast<T>(move_objects.at(index));
+        ASSERT(index < move_objects.size());
+        return DynamicObjectCast<T>(move_objects[index]);
    }

    void AddMoveObject(SharedPtr<Object> object) {
@@ -232,7 +232,7 @@ public:

    template <typename T>
    std::shared_ptr<T> GetDomainRequestHandler(std::size_t index) const {
-        return std::static_pointer_cast<T>(domain_request_handlers.at(index));
+        return std::static_pointer_cast<T>(domain_request_handlers[index]);
    }

    void SetDomainRequestHandlers(
@@ -12,7 +12,6 @@

 #include "core/core.h"
 #include "core/core_timing.h"
-#include "core/hle/kernel/address_arbiter.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
@@ -87,13 +86,11 @@ static void ThreadWakeupCallback(u64 thread_handle, [[maybe_unused]] int cycles_
 }

 struct KernelCore::Impl {
-    explicit Impl(Core::System& system) : address_arbiter{system}, system{system} {}
-
-    void Initialize(KernelCore& kernel) {
+    void Initialize(KernelCore& kernel, Core::Timing::CoreTiming& core_timing) {
        Shutdown();

        InitializeSystemResourceLimit(kernel);
-        InitializeThreads();
+        InitializeThreads(core_timing);
    }

    void Shutdown() {
@@ -125,9 +122,9 @@ struct KernelCore::Impl {
        ASSERT(system_resource_limit->SetLimitValue(ResourceType::Sessions, 900).IsSuccess());
    }

-    void InitializeThreads() {
+    void InitializeThreads(Core::Timing::CoreTiming& core_timing) {
        thread_wakeup_event_type =
-            system.CoreTiming().RegisterEvent("ThreadWakeupCallback", ThreadWakeupCallback);
+            core_timing.RegisterEvent("ThreadWakeupCallback", ThreadWakeupCallback);
    }

    std::atomic<u32> next_object_id{0};
@@ -138,8 +135,6 @@ struct KernelCore::Impl {
    std::vector<SharedPtr<Process>> process_list;
    Process* current_process = nullptr;

-    Kernel::AddressArbiter address_arbiter;
-
    SharedPtr<ResourceLimit> system_resource_limit;

    Core::Timing::EventType* thread_wakeup_event_type = nullptr;
@@ -150,18 +145,15 @@ struct KernelCore::Impl {
    /// Map of named ports managed by the kernel, which can be retrieved using
    /// the ConnectToPort SVC.
    NamedPortTable named_ports;
-
-    // System context
-    Core::System& system;
 };

-KernelCore::KernelCore(Core::System& system) : impl{std::make_unique<Impl>(system)} {}
+KernelCore::KernelCore() : impl{std::make_unique<Impl>()} {}
 KernelCore::~KernelCore() {
    Shutdown();
 }

-void KernelCore::Initialize() {
-    impl->Initialize(*this);
+void KernelCore::Initialize(Core::Timing::CoreTiming& core_timing) {
+    impl->Initialize(*this, core_timing);
 }

 void KernelCore::Shutdown() {
@@ -192,14 +184,6 @@ const Process* KernelCore::CurrentProcess() const {
    return impl->current_process;
 }

-AddressArbiter& KernelCore::AddressArbiter() {
-    return impl->address_arbiter;
-}
-
-const AddressArbiter& KernelCore::AddressArbiter() const {
-    return impl->address_arbiter;
-}
-
 void KernelCore::AddNamedPort(std::string name, SharedPtr<ClientPort> port) {
    impl->named_ports.emplace(std::move(name), std::move(port));
 }
@@ -11,10 +11,6 @@
 template <typename T>
 class ResultVal;

-namespace Core {
-class System;
-}
-
 namespace Core::Timing {
 class CoreTiming;
 struct EventType;
@@ -22,7 +18,6 @@ struct EventType;

 namespace Kernel {

-class AddressArbiter;
 class ClientPort;
 class HandleTable;
 class Process;
@@ -35,14 +30,7 @@ private:
    using NamedPortTable = std::unordered_map<std::string, SharedPtr<ClientPort>>;

 public:
-    /// Constructs an instance of the kernel using the given System
-    /// instance as a context for any necessary system-related state,
-    /// such as threads, CPU core state, etc.
-    ///
-    /// @post After execution of the constructor, the provided System
-    ///       object *must* outlive the kernel instance itself.
-    ///
-    explicit KernelCore(Core::System& system);
+    KernelCore();
    ~KernelCore();

    KernelCore(const KernelCore&) = delete;
@@ -52,7 +40,11 @@ public:
    KernelCore& operator=(KernelCore&&) = delete;

    /// Resets the kernel to a clean slate for use.
-    void Initialize();
+    ///
+    /// @param core_timing CoreTiming instance used to create any necessary
+    ///                    kernel-specific callback events.
+    ///
+    void Initialize(Core::Timing::CoreTiming& core_timing);

    /// Clears all resources in use by the kernel instance.
    void Shutdown();
@@ -75,12 +67,6 @@ public:
    /// Retrieves a const pointer to the current process.
    const Process* CurrentProcess() const;

-    /// Provides a reference to the kernel's address arbiter.
-    Kernel::AddressArbiter& AddressArbiter();
-
-    /// Provides a const reference to the kernel's address arbiter.
-    const Kernel::AddressArbiter& AddressArbiter() const;
-
    /// Adds a port to the named port table
    void AddNamedPort(std::string name, SharedPtr<ClientPort> port);

@@ -19,7 +19,8 @@ namespace Kernel {

 std::mutex Scheduler::scheduler_mutex;

-Scheduler::Scheduler(Core::ARM_Interface& cpu_core) : cpu_core(cpu_core) {}
+Scheduler::Scheduler(Core::System& system, Core::ARM_Interface& cpu_core)
+    : cpu_core{cpu_core}, system{system} {}

 Scheduler::~Scheduler() {
    for (auto& thread : thread_list) {
@@ -61,7 +62,7 @@ Thread* Scheduler::PopNextReadyThread() {

 void Scheduler::SwitchContext(Thread* new_thread) {
    Thread* const previous_thread = GetCurrentThread();
-    Process* const previous_process = Core::CurrentProcess();
+    Process* const previous_process = system.Kernel().CurrentProcess();

    UpdateLastContextSwitchTime(previous_thread, previous_process);

@@ -94,8 +95,8 @@ void Scheduler::SwitchContext(Thread* new_thread) {

        auto* const thread_owner_process = current_thread->GetOwnerProcess();
        if (previous_process != thread_owner_process) {
-            Core::System::GetInstance().Kernel().MakeCurrentProcess(thread_owner_process);
-            SetCurrentPageTable(&Core::CurrentProcess()->VMManager().page_table);
+            system.Kernel().MakeCurrentProcess(thread_owner_process);
+            SetCurrentPageTable(&thread_owner_process->VMManager().page_table);
        }

        cpu_core.LoadContext(new_thread->GetContext());
@@ -111,7 +112,7 @@ void Scheduler::SwitchContext(Thread* new_thread) {

 void Scheduler::UpdateLastContextSwitchTime(Thread* thread, Process* process) {
    const u64 prev_switch_ticks = last_context_switch_time;
-    const u64 most_recent_switch_ticks = Core::System::GetInstance().CoreTiming().GetTicks();
+    const u64 most_recent_switch_ticks = system.CoreTiming().GetTicks();
    const u64 update_ticks = most_recent_switch_ticks - prev_switch_ticks;

    if (thread != nullptr) {
@@ -223,8 +224,7 @@ void Scheduler::YieldWithLoadBalancing(Thread* thread) {
    // Take the first non-nullptr one
    for (unsigned cur_core = 0; cur_core < Core::NUM_CPU_CORES; ++cur_core) {
        const auto res =
-            Core::System::GetInstance().CpuCore(cur_core).Scheduler().GetNextSuggestedThread(
-                core, priority);
+            system.CpuCore(cur_core).Scheduler().GetNextSuggestedThread(core, priority);

        // If scheduler provides a suggested thread
        if (res != nullptr) {
@@ -13,7 +13,8 @@

 namespace Core {
 class ARM_Interface;
-}
+class System;
+} // namespace Core

 namespace Kernel {

@@ -21,7 +22,7 @@ class Process;

 class Scheduler final {
 public:
-    explicit Scheduler(Core::ARM_Interface& cpu_core);
+    explicit Scheduler(Core::System& system, Core::ARM_Interface& cpu_core);
    ~Scheduler();

    /// Returns whether there are any threads that are ready to run.
@@ -162,6 +163,7 @@ private:
    Core::ARM_Interface& cpu_core;
    u64 last_context_switch_time = 0;

+    Core::System& system;
    static std::mutex scheduler_mutex;
 };

@@ -20,7 +20,6 @@
 #include "core/hle/kernel/address_arbiter.h"
 #include "core/hle/kernel/client_port.h"
 #include "core/hle/kernel/client_session.h"
-#include "core/hle/kernel/errors.h"
 #include "core/hle/kernel/handle_table.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/mutex.h"
@@ -48,6 +47,23 @@ constexpr bool IsValidAddressRange(VAddr address, u64 size) {
    return address + size > address;
 }

+// Checks if a given address range lies within a larger address range.
+constexpr bool IsInsideAddressRange(VAddr address, u64 size, VAddr address_range_begin,
+                                    VAddr address_range_end) {
+    const VAddr end_address = address + size - 1;
+    return address_range_begin <= address && end_address <= address_range_end - 1;
+}
+
+bool IsInsideAddressSpace(const VMManager& vm, VAddr address, u64 size) {
+    return IsInsideAddressRange(address, size, vm.GetAddressSpaceBaseAddress(),
+                                vm.GetAddressSpaceEndAddress());
+}
+
+bool IsInsideNewMapRegion(const VMManager& vm, VAddr address, u64 size) {
+    return IsInsideAddressRange(address, size, vm.GetNewMapRegionBaseAddress(),
+                                vm.GetNewMapRegionEndAddress());
+}
+
 // 8 GiB
 constexpr u64 MAIN_MEMORY_SIZE = 0x200000000;

@@ -89,14 +105,14 @@ ResultCode MapUnmapMemorySanityChecks(const VMManager& vm_manager, VAddr dst_add
        return ERR_INVALID_ADDRESS_STATE;
    }

-    if (!vm_manager.IsWithinAddressSpace(src_addr, size)) {
+    if (!IsInsideAddressSpace(vm_manager, src_addr, size)) {
        LOG_ERROR(Kernel_SVC,
                  "Source is not within the address space, addr=0x{:016X}, size=0x{:016X}",
                  src_addr, size);
        return ERR_INVALID_ADDRESS_STATE;
    }

-    if (!vm_manager.IsWithinNewMapRegion(dst_addr, size)) {
+    if (!IsInsideNewMapRegion(vm_manager, dst_addr, size)) {
        LOG_ERROR(Kernel_SVC,
                  "Destination is not within the new map region, addr=0x{:016X}, size=0x{:016X}",
                  dst_addr, size);
@@ -222,7 +238,7 @@ static ResultCode SetMemoryPermission(VAddr addr, u64 size, u32 prot) {
    auto* const current_process = Core::CurrentProcess();
    auto& vm_manager = current_process->VMManager();

-    if (!vm_manager.IsWithinAddressSpace(addr, size)) {
+    if (!IsInsideAddressSpace(vm_manager, addr, size)) {
        LOG_ERROR(Kernel_SVC,
                  "Source is not within the address space, addr=0x{:016X}, size=0x{:016X}", addr,
                  size);
@@ -283,7 +299,7 @@ static ResultCode SetMemoryAttribute(VAddr address, u64 size, u32 mask, u32 attr
    }

    auto& vm_manager = Core::CurrentProcess()->VMManager();
-    if (!vm_manager.IsWithinAddressSpace(address, size)) {
+    if (!IsInsideAddressSpace(vm_manager, address, size)) {
        LOG_ERROR(Kernel_SVC,
                  "Given address (0x{:016X}) is outside the bounds of the address space.", address);
        return ERR_INVALID_ADDRESS_STATE;
@@ -1479,14 +1495,13 @@ static ResultCode WaitForAddress(VAddr address, u32 type, s32 value, s64 timeout
        return ERR_INVALID_ADDRESS;
    }

-    auto& address_arbiter = Core::System::GetInstance().Kernel().AddressArbiter();
    switch (static_cast<AddressArbiter::ArbitrationType>(type)) {
    case AddressArbiter::ArbitrationType::WaitIfLessThan:
-        return address_arbiter.WaitForAddressIfLessThan(address, value, timeout, false);
+        return AddressArbiter::WaitForAddressIfLessThan(address, value, timeout, false);
    case AddressArbiter::ArbitrationType::DecrementAndWaitIfLessThan:
-        return address_arbiter.WaitForAddressIfLessThan(address, value, timeout, true);
+        return AddressArbiter::WaitForAddressIfLessThan(address, value, timeout, true);
    case AddressArbiter::ArbitrationType::WaitIfEqual:
-        return address_arbiter.WaitForAddressIfEqual(address, value, timeout);
+        return AddressArbiter::WaitForAddressIfEqual(address, value, timeout);
    default:
        LOG_ERROR(Kernel_SVC,
                  "Invalid arbitration type, expected WaitIfLessThan, DecrementAndWaitIfLessThan "
@@ -1511,14 +1526,13 @@ static ResultCode SignalToAddress(VAddr address, u32 type, s32 value, s32 num_to
        return ERR_INVALID_ADDRESS;
    }

-    auto& address_arbiter = Core::System::GetInstance().Kernel().AddressArbiter();
    switch (static_cast<AddressArbiter::SignalType>(type)) {
    case AddressArbiter::SignalType::Signal:
-        return address_arbiter.SignalToAddress(address, num_to_wake);
+        return AddressArbiter::SignalToAddress(address, num_to_wake);
    case AddressArbiter::SignalType::IncrementAndSignalIfEqual:
-        return address_arbiter.IncrementAndSignalToAddressIfEqual(address, value, num_to_wake);
+        return AddressArbiter::IncrementAndSignalToAddressIfEqual(address, value, num_to_wake);
    case AddressArbiter::SignalType::ModifyByWaitingCountAndSignalIfEqual:
-        return address_arbiter.ModifyByWaitingCountAndSignalToAddressIfEqual(address, value,
+        return AddressArbiter::ModifyByWaitingCountAndSignalToAddressIfEqual(address, value,
                                                                             num_to_wake);
    default:
        LOG_ERROR(Kernel_SVC,
@@ -184,6 +184,8 @@ ResultVal<SharedPtr<Thread>> Thread::Create(KernelCore& kernel, std::string name
        return ERR_INVALID_PROCESSOR_ID;
    }

+    // TODO(yuriks): Other checks, returning 0xD9001BEA
+
    if (!Memory::IsValidVirtualAddress(owner_process, entry_point)) {
        LOG_ERROR(Kernel_SVC, "(name={}): invalid entry {:016X}", name, entry_point);
        // TODO (bunnei): Find the correct error code to use here
@@ -17,8 +17,8 @@
 #include "core/memory_setup.h"

 namespace Kernel {
-namespace {
-const char* GetMemoryStateName(MemoryState state) {
+
+static const char* GetMemoryStateName(MemoryState state) {
    static constexpr const char* names[] = {
        "Unmapped",         "Io",
        "Normal",           "CodeStatic",
@@ -35,14 +35,6 @@ const char* GetMemoryStateName(MemoryState state) {
    return names[ToSvcMemoryState(state)];
 }

-// Checks if a given address range lies within a larger address range.
-constexpr bool IsInsideAddressRange(VAddr address, u64 size, VAddr address_range_begin,
-                                    VAddr address_range_end) {
-    const VAddr end_address = address + size - 1;
-    return address_range_begin <= address && end_address <= address_range_end - 1;
-}
-} // Anonymous namespace
-
 bool VirtualMemoryArea::CanBeMergedWith(const VirtualMemoryArea& next) const {
    ASSERT(base + size == next.base);
    if (permissions != next.permissions || state != next.state || attribute != next.attribute ||
@@ -257,7 +249,8 @@ ResultCode VMManager::ReprotectRange(VAddr target, u64 size, VMAPermission new_p
 }

 ResultVal<VAddr> VMManager::HeapAllocate(VAddr target, u64 size, VMAPermission perms) {
-    if (!IsWithinHeapRegion(target, size)) {
+    if (target < GetHeapRegionBaseAddress() || target + size > GetHeapRegionEndAddress() ||
+        target + size < target) {
        return ERR_INVALID_ADDRESS;
    }

@@ -292,7 +285,8 @@ ResultVal<VAddr> VMManager::HeapAllocate(VAddr target, u64 size, VMAPermission p
 }

 ResultCode VMManager::HeapFree(VAddr target, u64 size) {
-    if (!IsWithinHeapRegion(target, size)) {
+    if (target < GetHeapRegionBaseAddress() || target + size > GetHeapRegionEndAddress() ||
+        target + size < target) {
        return ERR_INVALID_ADDRESS;
    }

@@ -712,11 +706,6 @@ u64 VMManager::GetAddressSpaceWidth() const {
    return address_space_width;
 }

-bool VMManager::IsWithinAddressSpace(VAddr address, u64 size) const {
-    return IsInsideAddressRange(address, size, GetAddressSpaceBaseAddress(),
-                                GetAddressSpaceEndAddress());
-}
-
 VAddr VMManager::GetASLRRegionBaseAddress() const {
    return aslr_region_base;
 }
@@ -761,11 +750,6 @@ u64 VMManager::GetCodeRegionSize() const {
    return code_region_end - code_region_base;
 }

-bool VMManager::IsWithinCodeRegion(VAddr address, u64 size) const {
-    return IsInsideAddressRange(address, size, GetCodeRegionBaseAddress(),
-                                GetCodeRegionEndAddress());
-}
-
 VAddr VMManager::GetHeapRegionBaseAddress() const {
    return heap_region_base;
 }
@@ -778,11 +762,6 @@ u64 VMManager::GetHeapRegionSize() const {
    return heap_region_end - heap_region_base;
 }

-bool VMManager::IsWithinHeapRegion(VAddr address, u64 size) const {
-    return IsInsideAddressRange(address, size, GetHeapRegionBaseAddress(),
-                                GetHeapRegionEndAddress());
-}
-
 VAddr VMManager::GetMapRegionBaseAddress() const {
    return map_region_base;
 }
@@ -795,10 +774,6 @@ u64 VMManager::GetMapRegionSize() const {
    return map_region_end - map_region_base;
 }

-bool VMManager::IsWithinMapRegion(VAddr address, u64 size) const {
-    return IsInsideAddressRange(address, size, GetMapRegionBaseAddress(), GetMapRegionEndAddress());
-}
-
 VAddr VMManager::GetNewMapRegionBaseAddress() const {
    return new_map_region_base;
 }
@@ -811,11 +786,6 @@ u64 VMManager::GetNewMapRegionSize() const {
    return new_map_region_end - new_map_region_base;
 }

-bool VMManager::IsWithinNewMapRegion(VAddr address, u64 size) const {
-    return IsInsideAddressRange(address, size, GetNewMapRegionBaseAddress(),
-                                GetNewMapRegionEndAddress());
-}
-
 VAddr VMManager::GetTLSIORegionBaseAddress() const {
    return tls_io_region_base;
 }
@@ -828,9 +798,4 @@ u64 VMManager::GetTLSIORegionSize() const {
    return tls_io_region_end - tls_io_region_base;
 }

-bool VMManager::IsWithinTLSIORegion(VAddr address, u64 size) const {
-    return IsInsideAddressRange(address, size, GetTLSIORegionBaseAddress(),
-                                GetTLSIORegionEndAddress());
-}
-
 } // namespace Kernel
@@ -432,21 +432,18 @@ public:
    /// Gets the address space width in bits.
    u64 GetAddressSpaceWidth() const;

-    /// Determines whether or not the given address range lies within the address space.
-    bool IsWithinAddressSpace(VAddr address, u64 size) const;
-
    /// Gets the base address of the ASLR region.
    VAddr GetASLRRegionBaseAddress() const;

    /// Gets the end address of the ASLR region.
    VAddr GetASLRRegionEndAddress() const;

-    /// Gets the size of the ASLR region
-    u64 GetASLRRegionSize() const;
-
    /// Determines whether or not the specified address range is within the ASLR region.
    bool IsWithinASLRRegion(VAddr address, u64 size) const;

+    /// Gets the size of the ASLR region
+    u64 GetASLRRegionSize() const;
+
    /// Gets the base address of the code region.
    VAddr GetCodeRegionBaseAddress() const;

@@ -456,9 +453,6 @@ public:
    /// Gets the total size of the code region in bytes.
    u64 GetCodeRegionSize() const;

-    /// Determines whether or not the specified range is within the code region.
-    bool IsWithinCodeRegion(VAddr address, u64 size) const;
-
    /// Gets the base address of the heap region.
    VAddr GetHeapRegionBaseAddress() const;

@@ -468,9 +462,6 @@ public:
    /// Gets the total size of the heap region in bytes.
    u64 GetHeapRegionSize() const;

-    /// Determines whether or not the specified range is within the heap region.
-    bool IsWithinHeapRegion(VAddr address, u64 size) const;
-
    /// Gets the base address of the map region.
    VAddr GetMapRegionBaseAddress() const;

@@ -480,9 +471,6 @@ public:
    /// Gets the total size of the map region in bytes.
    u64 GetMapRegionSize() const;

-    /// Determines whether or not the specified range is within the map region.
-    bool IsWithinMapRegion(VAddr address, u64 size) const;
-
    /// Gets the base address of the new map region.
    VAddr GetNewMapRegionBaseAddress() const;

@@ -492,9 +480,6 @@ public:
    /// Gets the total size of the new map region in bytes.
    u64 GetNewMapRegionSize() const;

-    /// Determines whether or not the given address range is within the new map region
-    bool IsWithinNewMapRegion(VAddr address, u64 size) const;
-
    /// Gets the base address of the TLS IO region.
    VAddr GetTLSIORegionBaseAddress() const;

@@ -504,9 +489,6 @@ public:
    /// Gets the total size of the TLS IO region in bytes.
    u64 GetTLSIORegionSize() const;

-    /// Determines if the given address range is within the TLS IO region.
-    bool IsWithinTLSIORegion(VAddr address, u64 size) const;
-
    /// Each VMManager has its own page table, which is set as the main one when the owning process
    /// is scheduled.
    Memory::PageTable page_table;
@@ -8,6 +8,7 @@
 #include <utility>
 #include "common/assert.h"
 #include "common/bit_field.h"
+#include "common/common_funcs.h"
 #include "common/common_types.h"

 // All the constants in this file come from http://switchbrew.org/index.php?title=Error_codes
@@ -7,7 +7,6 @@
 #include "common/string_util.h"
 #include "core/core.h"
 #include "core/frontend/applets/software_keyboard.h"
-#include "core/hle/result.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applets/software_keyboard.h"

@@ -9,13 +9,10 @@
 #include <vector>

 #include "common/common_funcs.h"
-#include "common/common_types.h"
 #include "common/swap.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applets/applets.h"

-union ResultCode;
-
 namespace Service::AM::Applets {

 enum class KeysetDisable : u32 {
@@ -18,11 +18,17 @@
 #include "core/hle/kernel/readable_event.h"
 #include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/audio/audout_u.h"
-#include "core/hle/service/audio/errors.h"
 #include "core/memory.h"

 namespace Service::Audio {

+namespace ErrCodes {
+enum {
+    ErrorUnknown = 2,
+    BufferCountExceeded = 8,
+};
+}
+
 constexpr std::array<char, 10> DefaultDevice{{"DeviceOut"}};
 constexpr int DefaultSampleRate{48000};

@@ -94,7 +100,7 @@ private:

        if (stream->IsPlaying()) {
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_OPERATION_FAILED);
+            rb.Push(ResultCode(ErrorModule::Audio, ErrCodes::ErrorUnknown));
            return;
        }

@@ -137,8 +143,7 @@ private:

        if (!audio_core.QueueBuffer(stream, tag, std::move(samples))) {
            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_BUFFER_COUNT_EXCEEDED);
-            return;
+            rb.Push(ResultCode(ErrorModule::Audio, ErrCodes::BufferCountExceeded));
        }

        IPC::ResponseBuilder rb{ctx, 2};
@@ -17,7 +17,6 @@
 #include "core/hle/kernel/readable_event.h"
 #include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/audio/audren_u.h"
-#include "core/hle/service/audio/errors.h"

 namespace Service::Audio {

@@ -147,7 +146,7 @@ private:
        // code in this case.

        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ERR_NOT_SUPPORTED);
+        rb.Push(ResultCode{ErrorModule::Audio, 201});
    }

    Kernel::EventPair system_event;
@@ -1,15 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "core/hle/result.h"
-
-namespace Service::Audio {
-
-constexpr ResultCode ERR_OPERATION_FAILED{ErrorModule::Audio, 2};
-constexpr ResultCode ERR_BUFFER_COUNT_EXCEEDED{ErrorModule::Audio, 8};
-constexpr ResultCode ERR_NOT_SUPPORTED{ErrorModule::Audio, 513};
-
-} // namespace Service::Audio
@@ -36,7 +36,7 @@ void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u3

    auto& instance = Core::System::GetInstance();
    instance.GetPerfStats().EndGameFrame();
-    instance.GPU().SwapBuffers(framebuffer);
+    instance.Renderer().SwapBuffers(framebuffer);
 }

 } // namespace Service::Nvidia::Devices
@@ -178,7 +178,7 @@ u32 nvhost_as_gpu::UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& ou
    auto& gpu = system_instance.GPU();
    auto cpu_addr = gpu.MemoryManager().GpuToCpuAddress(params.offset);
    ASSERT(cpu_addr);
-    gpu.FlushAndInvalidateRegion(*cpu_addr, itr->second.size);
+    system_instance.Renderer().Rasterizer().FlushAndInvalidateRegion(*cpu_addr, itr->second.size);

    params.offset = gpu.MemoryManager().UnmapBuffer(params.offset, itr->second.size);

@@ -136,6 +136,16 @@ u32 nvhost_gpu::AllocateObjectContext(const std::vector<u8>& input, std::vector<
    return 0;
 }

+static void PushGPUEntries(Tegra::CommandList&& entries) {
+    if (entries.empty()) {
+        return;
+    }
+
+    auto& dma_pusher{Core::System::GetInstance().GPU().DmaPusher()};
+    dma_pusher.Push(std::move(entries));
+    dma_pusher.DispatchCalls();
+}
+
 u32 nvhost_gpu::SubmitGPFIFO(const std::vector<u8>& input, std::vector<u8>& output) {
    if (input.size() < sizeof(IoctlSubmitGpfifo)) {
        UNIMPLEMENTED();
@@ -153,7 +163,7 @@ u32 nvhost_gpu::SubmitGPFIFO(const std::vector<u8>& input, std::vector<u8>& outp
    std::memcpy(entries.data(), &input[sizeof(IoctlSubmitGpfifo)],
                params.num_entries * sizeof(Tegra::CommandListHeader));

-    Core::System::GetInstance().GPU().PushGPUEntries(std::move(entries));
+    PushGPUEntries(std::move(entries));

    params.fence_out.id = 0;
    params.fence_out.value = 0;
@@ -174,7 +184,7 @@ u32 nvhost_gpu::KickoffPB(const std::vector<u8>& input, std::vector<u8>& output)
    Memory::ReadBlock(params.address, entries.data(),
                      params.num_entries * sizeof(Tegra::CommandListHeader));

-    Core::System::GetInstance().GPU().PushGPUEntries(std::move(entries));
+    PushGPUEntries(std::move(entries));

    params.fence_out.id = 0;
    params.fence_out.value = 0;
@@ -186,7 +186,7 @@ void NVFlinger::Compose() {

            // There was no queued buffer to draw, render previous frame
            system_instance.GetPerfStats().EndGameFrame();
-            system_instance.GPU().SwapBuffers({});
+            system_instance.Renderer().SwapBuffers({});
            continue;
        }

@@ -171,6 +171,9 @@ T Read(const VAddr vaddr) {
        return value;
    }

+    // The memory access might do an MMIO or cached access, so we have to lock the HLE kernel state
+    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
+
    PageType type = current_page_table->attributes[vaddr >> PAGE_BITS];
    switch (type) {
    case PageType::Unmapped:
@@ -201,6 +204,9 @@ void Write(const VAddr vaddr, const T data) {
        return;
    }

+    // The memory access might do an MMIO or cached access, so we have to lock the HLE kernel state
+    std::lock_guard<std::recursive_mutex> lock(HLE::g_hle_lock);
+
    PageType type = current_page_table->attributes[vaddr >> PAGE_BITS];
    switch (type) {
    case PageType::Unmapped:
@@ -356,16 +362,16 @@ void RasterizerFlushVirtualRegion(VAddr start, u64 size, FlushMode mode) {
        const VAddr overlap_end = std::min(end, region_end);
        const VAddr overlap_size = overlap_end - overlap_start;

-        auto& gpu = system_instance.GPU();
+        auto& rasterizer = system_instance.Renderer().Rasterizer();
        switch (mode) {
        case FlushMode::Flush:
-            gpu.FlushRegion(overlap_start, overlap_size);
+            rasterizer.FlushRegion(overlap_start, overlap_size);
            break;
        case FlushMode::Invalidate:
-            gpu.InvalidateRegion(overlap_start, overlap_size);
+            rasterizer.InvalidateRegion(overlap_start, overlap_size);
            break;
        case FlushMode::FlushAndInvalidate:
-            gpu.FlushAndInvalidateRegion(overlap_start, overlap_size);
+            rasterizer.FlushAndInvalidateRegion(overlap_start, overlap_size);
            break;
        }
    };
@@ -393,7 +393,6 @@ struct Values {
    u16 frame_limit;
    bool use_disk_shader_cache;
    bool use_accurate_gpu_emulation;
-    bool use_asynchronous_gpu_emulation;

    float bg_red;
    float bg_green;
@@ -162,8 +162,6 @@ TelemetrySession::TelemetrySession() {
             Settings::values.use_disk_shader_cache);
    AddField(Telemetry::FieldType::UserConfig, "Renderer_UseAccurateGpuEmulation",
             Settings::values.use_accurate_gpu_emulation);
-    AddField(Telemetry::FieldType::UserConfig, "Renderer_UseAsynchronousGpuEmulation",
-             Settings::values.use_asynchronous_gpu_emulation);
    AddField(Telemetry::FieldType::UserConfig, "System_UseDockedMode",
             Settings::values.use_docked_mode);
 }
@@ -13,11 +13,11 @@
 namespace ArmTests {

 TestEnvironment::TestEnvironment(bool mutable_memory_)
-    : mutable_memory(mutable_memory_),
-      test_memory(std::make_shared<TestMemory>(this)), kernel{Core::System::GetInstance()} {
+    : mutable_memory(mutable_memory_), test_memory(std::make_shared<TestMemory>(this)) {
+
    auto process = Kernel::Process::Create(kernel, "");
    kernel.MakeCurrentProcess(process.get());
-    page_table = &process->VMManager().page_table;
+    page_table = &Core::CurrentProcess()->VMManager().page_table;

    std::fill(page_table->pointers.begin(), page_table->pointers.end(), nullptr);
    page_table->special_regions.clear();
@@ -17,12 +17,6 @@ add_library(video_core STATIC
    engines/shader_header.h
    gpu.cpp
    gpu.h
-    gpu_asynch.cpp
-    gpu_asynch.h
-    gpu_synch.cpp
-    gpu_synch.h
-    gpu_thread.cpp
-    gpu_thread.h
    macro_interpreter.cpp
    macro_interpreter.h
    memory_manager.cpp
@@ -100,8 +94,6 @@ add_library(video_core STATIC
    surface.h
    textures/astc.cpp
    textures/astc.h
-    textures/convert.cpp
-    textures/convert.h
    textures/decoders.cpp
    textures/decoders.h
    textures/texture.h
@@ -2,11 +2,12 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-#include "common/assert.h"
-#include "common/logging/log.h"
-#include "common/math_util.h"
+#include "core/core.h"
+#include "core/memory.h"
 #include "video_core/engines/fermi_2d.h"
+#include "video_core/engines/maxwell_3d.h"
 #include "video_core/rasterizer_interface.h"
+#include "video_core/textures/decoders.h"

 namespace Tegra::Engines {

@@ -5,7 +5,7 @@
 #pragma once

 #include <array>
-#include <cstddef>
+#include "common/assert.h"
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -2,8 +2,9 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-#include "common/assert.h"
 #include "common/logging/log.h"
+#include "core/core.h"
+#include "core/memory.h"
 #include "video_core/engines/kepler_compute.h"
 #include "video_core/memory_manager.h"

@@ -5,7 +5,8 @@
 #pragma once

 #include <array>
-#include <cstddef>
+#include "common/assert.h"
+#include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "video_core/gpu.h"
@@ -48,7 +48,7 @@ void KeplerMemory::ProcessData(u32 data) {
    // We have to invalidate the destination region to evict any outdated surfaces from the cache.
    // We do this before actually writing the new data because the destination address might contain
    // a dirty surface that will have to be written back to memory.
-    Core::System::GetInstance().GPU().InvalidateRegion(*dest_address, sizeof(u32));
+    rasterizer.InvalidateRegion(*dest_address, sizeof(u32));

    Memory::Write32(*dest_address, data);
    system.GPU().Maxwell3D().dirty_flags.OnMemoryWrite();
@@ -5,7 +5,6 @@
 #pragma once

 #include <array>
-#include <cstddef>
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.

 #include "common/assert.h"
-#include "common/logging/log.h"
 #include "core/core.h"
 #include "core/memory.h"
 #include "video_core/engines/maxwell_3d.h"
@@ -92,12 +91,12 @@ void MaxwellDMA::HandleCopy() {
    const auto FlushAndInvalidate = [&](u32 src_size, u64 dst_size) {
        // TODO(Subv): For now, manually flush the regions until we implement GPU-accelerated
        // copying.
-        Core::System::GetInstance().GPU().FlushRegion(*source_cpu, src_size);
+        rasterizer.FlushRegion(*source_cpu, src_size);

        // We have to invalidate the destination region to evict any outdated surfaces from the
        // cache. We do this before actually writing the new data because the destination address
        // might contain a dirty surface that will have to be written back to memory.
-        Core::System::GetInstance().GPU().InvalidateRegion(*dest_cpu, dst_size);
+        rasterizer.InvalidateRegion(*dest_cpu, dst_size);
    };

    if (regs.exec.is_dst_linear && !regs.exec.is_src_linear) {
@@ -5,7 +5,6 @@
 #pragma once

 #include <array>
-#include <cstddef>
 #include "common/bit_field.h"
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -6,6 +6,7 @@

 #include <bitset>
 #include <optional>
+#include <string>
 #include <tuple>
 #include <vector>

@@ -12,7 +12,7 @@
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/engines/maxwell_dma.h"
 #include "video_core/gpu.h"
-#include "video_core/renderer_base.h"
+#include "video_core/rasterizer_interface.h"

 namespace Tegra {

@@ -28,8 +28,7 @@ u32 FramebufferConfig::BytesPerPixel(PixelFormat format) {
    UNREACHABLE();
 }

-GPU::GPU(Core::System& system, VideoCore::RendererBase& renderer) : renderer{renderer} {
-    auto& rasterizer{renderer.Rasterizer()};
+GPU::GPU(Core::System& system, VideoCore::RasterizerInterface& rasterizer) {
    memory_manager = std::make_unique<Tegra::MemoryManager>();
    dma_pusher = std::make_unique<Tegra::DmaPusher>(*this);
    maxwell_3d = std::make_unique<Engines::Maxwell3D>(system, rasterizer, *memory_manager);
@@ -16,8 +16,8 @@ class System;
 }

 namespace VideoCore {
-class RendererBase;
-} // namespace VideoCore
+class RasterizerInterface;
+}

 namespace Tegra {

@@ -119,10 +119,9 @@ enum class EngineID {
    MAXWELL_DMA_COPY_A = 0xB0B5,
 };

-class GPU {
+class GPU final {
 public:
-    explicit GPU(Core::System& system, VideoCore::RendererBase& renderer);
-
+    explicit GPU(Core::System& system, VideoCore::RasterizerInterface& rasterizer);
    ~GPU();

    struct MethodCall {
@@ -201,42 +200,8 @@ public:
        };
    } regs{};

-    /// Push GPU command entries to be processed
-    virtual void PushGPUEntries(Tegra::CommandList&& entries) = 0;
-
-    /// Swap buffers (render frame)
-    virtual void SwapBuffers(
-        std::optional<std::reference_wrapper<const Tegra::FramebufferConfig>> framebuffer) = 0;
-
-    /// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
-    virtual void FlushRegion(VAddr addr, u64 size) = 0;
-
-    /// Notify rasterizer that any caches of the specified region should be invalidated
-    virtual void InvalidateRegion(VAddr addr, u64 size) = 0;
-
-    /// Notify rasterizer that any caches of the specified region should be flushed and invalidated
-    virtual void FlushAndInvalidateRegion(VAddr addr, u64 size) = 0;
-
 private:
-    void ProcessBindMethod(const MethodCall& method_call);
-    void ProcessSemaphoreTriggerMethod();
-    void ProcessSemaphoreRelease();
-    void ProcessSemaphoreAcquire();
-
-    /// Calls a GPU puller method.
-    void CallPullerMethod(const MethodCall& method_call);
-
-    /// Calls a GPU engine method.
-    void CallEngineMethod(const MethodCall& method_call);
-
-    /// Determines where the method should be executed.
-    bool ExecuteMethodOnEngine(const MethodCall& method_call);
-
-protected:
    std::unique_ptr<Tegra::DmaPusher> dma_pusher;
-    VideoCore::RendererBase& renderer;
-
-private:
    std::unique_ptr<Tegra::MemoryManager> memory_manager;

    /// Mapping of command subchannels to their bound engine ids.
@@ -252,6 +217,18 @@ private:
    std::unique_ptr<Engines::MaxwellDMA> maxwell_dma;
    /// Inline memory engine
    std::unique_ptr<Engines::KeplerMemory> kepler_memory;
+
+    void ProcessBindMethod(const MethodCall& method_call);
+    void ProcessSemaphoreTriggerMethod();
+    void ProcessSemaphoreRelease();
+    void ProcessSemaphoreAcquire();
+
+    // Calls a GPU puller method.
+    void CallPullerMethod(const MethodCall& method_call);
+    // Calls a GPU engine method.
+    void CallEngineMethod(const MethodCall& method_call);
+    // Determines where the method should be executed.
+    bool ExecuteMethodOnEngine(const MethodCall& method_call);
 };

 #define ASSERT_REG_POSITION(field_name, position)                                                  \
@@ -1,37 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "video_core/gpu_asynch.h"
-#include "video_core/gpu_thread.h"
-#include "video_core/renderer_base.h"
-
-namespace VideoCommon {
-
-GPUAsynch::GPUAsynch(Core::System& system, VideoCore::RendererBase& renderer)
-    : Tegra::GPU(system, renderer), gpu_thread{renderer, *dma_pusher} {}
-
-GPUAsynch::~GPUAsynch() = default;
-
-void GPUAsynch::PushGPUEntries(Tegra::CommandList&& entries) {
-    gpu_thread.SubmitList(std::move(entries));
-}
-
-void GPUAsynch::SwapBuffers(
-    std::optional<std::reference_wrapper<const Tegra::FramebufferConfig>> framebuffer) {
-    gpu_thread.SwapBuffers(std::move(framebuffer));
-}
-
-void GPUAsynch::FlushRegion(VAddr addr, u64 size) {
-    gpu_thread.FlushRegion(addr, size);
-}
-
-void GPUAsynch::InvalidateRegion(VAddr addr, u64 size) {
-    gpu_thread.InvalidateRegion(addr, size);
-}
-
-void GPUAsynch::FlushAndInvalidateRegion(VAddr addr, u64 size) {
-    gpu_thread.FlushAndInvalidateRegion(addr, size);
-}
-
-} // namespace VideoCommon
@@ -1,37 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "video_core/gpu.h"
-#include "video_core/gpu_thread.h"
-
-namespace VideoCore {
-class RendererBase;
-} // namespace VideoCore
-
-namespace VideoCommon {
-
-namespace GPUThread {
-class ThreadManager;
-} // namespace GPUThread
-
-/// Implementation of GPU interface that runs the GPU asynchronously
-class GPUAsynch : public Tegra::GPU {
-public:
-    explicit GPUAsynch(Core::System& system, VideoCore::RendererBase& renderer);
-    ~GPUAsynch();
-
-    void PushGPUEntries(Tegra::CommandList&& entries) override;
-    void SwapBuffers(
-        std::optional<std::reference_wrapper<const Tegra::FramebufferConfig>> framebuffer) override;
-    void FlushRegion(VAddr addr, u64 size) override;
-    void InvalidateRegion(VAddr addr, u64 size) override;
-    void FlushAndInvalidateRegion(VAddr addr, u64 size) override;
-
-private:
-    GPUThread::ThreadManager gpu_thread;
-};
-
-} // namespace VideoCommon
@@ -1,37 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "video_core/gpu_synch.h"
-#include "video_core/renderer_base.h"
-
-namespace VideoCommon {
-
-GPUSynch::GPUSynch(Core::System& system, VideoCore::RendererBase& renderer)
-    : Tegra::GPU(system, renderer) {}
-
-GPUSynch::~GPUSynch() = default;
-
-void GPUSynch::PushGPUEntries(Tegra::CommandList&& entries) {
-    dma_pusher->Push(std::move(entries));
-    dma_pusher->DispatchCalls();
-}
-
-void GPUSynch::SwapBuffers(
-    std::optional<std::reference_wrapper<const Tegra::FramebufferConfig>> framebuffer) {
-    renderer.SwapBuffers(std::move(framebuffer));
-}
-
-void GPUSynch::FlushRegion(VAddr addr, u64 size) {
-    renderer.Rasterizer().FlushRegion(addr, size);
-}
-
-void GPUSynch::InvalidateRegion(VAddr addr, u64 size) {
-    renderer.Rasterizer().InvalidateRegion(addr, size);
-}
-
-void GPUSynch::FlushAndInvalidateRegion(VAddr addr, u64 size) {
-    renderer.Rasterizer().FlushAndInvalidateRegion(addr, size);
-}
-
-} // namespace VideoCommon
@@ -1,29 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "video_core/gpu.h"
-
-namespace VideoCore {
-class RendererBase;
-} // namespace VideoCore
-
-namespace VideoCommon {
-
-/// Implementation of GPU interface that runs the GPU synchronously
-class GPUSynch : public Tegra::GPU {
-public:
-    explicit GPUSynch(Core::System& system, VideoCore::RendererBase& renderer);
-    ~GPUSynch();
-
-    void PushGPUEntries(Tegra::CommandList&& entries) override;
-    void SwapBuffers(
-        std::optional<std::reference_wrapper<const Tegra::FramebufferConfig>> framebuffer) override;
-    void FlushRegion(VAddr addr, u64 size) override;
-    void InvalidateRegion(VAddr addr, u64 size) override;
-    void FlushAndInvalidateRegion(VAddr addr, u64 size) override;
-};
-
-} // namespace VideoCommon
@@ -1,152 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "common/assert.h"
-#include "common/microprofile.h"
-#include "core/frontend/scope_acquire_window_context.h"
-#include "core/settings.h"
-#include "video_core/dma_pusher.h"
-#include "video_core/gpu.h"
-#include "video_core/gpu_thread.h"
-#include "video_core/renderer_base.h"
-
-namespace VideoCommon::GPUThread {
-
-/// Executes a single GPU thread command
-static void ExecuteCommand(CommandData* command, VideoCore::RendererBase& renderer,
-                           Tegra::DmaPusher& dma_pusher) {
-    if (const auto submit_list = std::get_if<SubmitListCommand>(command)) {
-        dma_pusher.Push(std::move(submit_list->entries));
-        dma_pusher.DispatchCalls();
-    } else if (const auto data = std::get_if<SwapBuffersCommand>(command)) {
-        renderer.SwapBuffers(data->framebuffer);
-    } else if (const auto data = std::get_if<FlushRegionCommand>(command)) {
-        renderer.Rasterizer().FlushRegion(data->addr, data->size);
-    } else if (const auto data = std::get_if<InvalidateRegionCommand>(command)) {
-        renderer.Rasterizer().InvalidateRegion(data->addr, data->size);
-    } else if (const auto data = std::get_if<FlushAndInvalidateRegionCommand>(command)) {
-        renderer.Rasterizer().FlushAndInvalidateRegion(data->addr, data->size);
-    } else {
-        UNREACHABLE();
-    }
-}
-
-/// Runs the GPU thread
-static void RunThread(VideoCore::RendererBase& renderer, Tegra::DmaPusher& dma_pusher,
-                      SynchState& state) {
-
-    MicroProfileOnThreadCreate("GpuThread");
-
-    auto WaitForWakeup = [&]() {
-        std::unique_lock<std::mutex> lock{state.signal_mutex};
-        state.signal_condition.wait(lock, [&] { return !state.is_idle || !state.is_running; });
-    };
-
-    // Wait for first GPU command before acquiring the window context
-    WaitForWakeup();
-
-    // If emulation was stopped during disk shader loading, abort before trying to acquire context
-    if (!state.is_running) {
-        return;
-    }
-
-    Core::Frontend::ScopeAcquireWindowContext acquire_context{renderer.GetRenderWindow()};
-
-    while (state.is_running) {
-        if (!state.is_running) {
-            return;
-        }
-
-        {
-            // Thread has been woken up, so make the previous write queue the next read queue
-            std::lock_guard<std::mutex> lock{state.signal_mutex};
-            std::swap(state.push_queue, state.pop_queue);
-        }
-
-        // Execute all of the GPU commands
-        while (!state.pop_queue->empty()) {
-            ExecuteCommand(&state.pop_queue->front(), renderer, dma_pusher);
-            state.pop_queue->pop();
-        }
-
-        state.UpdateIdleState();
-
-        // Signal that the GPU thread has finished processing commands
-        if (state.is_idle) {
-            state.idle_condition.notify_one();
-        }
-
-        // Wait for CPU thread to send more GPU commands
-        WaitForWakeup();
-    }
-}
-
-ThreadManager::ThreadManager(VideoCore::RendererBase& renderer, Tegra::DmaPusher& dma_pusher)
-    : renderer{renderer}, dma_pusher{dma_pusher}, thread{RunThread, std::ref(renderer),
-                                                         std::ref(dma_pusher), std::ref(state)},
-      thread_id{thread.get_id()} {}
-
-ThreadManager::~ThreadManager() {
-    {
-        // Notify GPU thread that a shutdown is pending
-        std::lock_guard<std::mutex> lock{state.signal_mutex};
-        state.is_running = false;
-    }
-
-    state.signal_condition.notify_one();
-    thread.join();
-}
-
-void ThreadManager::SubmitList(Tegra::CommandList&& entries) {
-    if (entries.empty()) {
-        return;
-    }
-
-    PushCommand(SubmitListCommand(std::move(entries)), false, false);
-}
-
-void ThreadManager::SwapBuffers(
-    std::optional<std::reference_wrapper<const Tegra::FramebufferConfig>> framebuffer) {
-    PushCommand(SwapBuffersCommand(std::move(framebuffer)), true, false);
-}
-
-void ThreadManager::FlushRegion(VAddr addr, u64 size) {
-    // Block the CPU when using accurate emulation
-    PushCommand(FlushRegionCommand(addr, size), Settings::values.use_accurate_gpu_emulation, false);
-}
-
-void ThreadManager::InvalidateRegion(VAddr addr, u64 size) {
-    PushCommand(InvalidateRegionCommand(addr, size), true, true);
-}
-
-void ThreadManager::FlushAndInvalidateRegion(VAddr addr, u64 size) {
-    InvalidateRegion(addr, size);
-}
-
-void ThreadManager::PushCommand(CommandData&& command_data, bool wait_for_idle, bool allow_on_cpu) {
-    {
-        std::lock_guard<std::mutex> lock{state.signal_mutex};
-
-        if ((allow_on_cpu && state.is_idle) || IsGpuThread()) {
-            // Execute the command synchronously on the current thread
-            ExecuteCommand(&command_data, renderer, dma_pusher);
-            return;
-        }
-
-        // Push the command to the GPU thread
-        state.UpdateIdleState();
-        state.push_queue->emplace(command_data);
-    }
-
-    // Signal the GPU thread that commands are pending
-    state.signal_condition.notify_one();
-
-    if (wait_for_idle) {
-        // Wait for the GPU to be idle (all commands to be executed)
-        std::unique_lock<std::mutex> lock{state.idle_mutex};
-        state.idle_condition.wait(lock, [this] { return static_cast<bool>(state.is_idle); });
-    }
-}
-
-} // namespace VideoCommon::GPUThread
@@ -1,136 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <array>
-#include <atomic>
-#include <condition_variable>
-#include <memory>
-#include <mutex>
-#include <optional>
-#include <thread>
-#include <variant>
-
-namespace Tegra {
-struct FramebufferConfig;
-class DmaPusher;
-} // namespace Tegra
-
-namespace VideoCore {
-class RendererBase;
-} // namespace VideoCore
-
-namespace VideoCommon::GPUThread {
-
-/// Command to signal to the GPU thread that a command list is ready for processing
-struct SubmitListCommand final {
-    explicit SubmitListCommand(Tegra::CommandList&& entries) : entries{std::move(entries)} {}
-
-    Tegra::CommandList entries;
-};
-
-/// Command to signal to the GPU thread that a swap buffers is pending
-struct SwapBuffersCommand final {
-    explicit SwapBuffersCommand(std::optional<const Tegra::FramebufferConfig> framebuffer)
-        : framebuffer{std::move(framebuffer)} {}
-
-    std::optional<const Tegra::FramebufferConfig> framebuffer;
-};
-
-/// Command to signal to the GPU thread to flush a region
-struct FlushRegionCommand final {
-    explicit constexpr FlushRegionCommand(VAddr addr, u64 size) : addr{addr}, size{size} {}
-
-    const VAddr addr;
-    const u64 size;
-};
-
-/// Command to signal to the GPU thread to invalidate a region
-struct InvalidateRegionCommand final {
-    explicit constexpr InvalidateRegionCommand(VAddr addr, u64 size) : addr{addr}, size{size} {}
-
-    const VAddr addr;
-    const u64 size;
-};
-
-/// Command to signal to the GPU thread to flush and invalidate a region
-struct FlushAndInvalidateRegionCommand final {
-    explicit constexpr FlushAndInvalidateRegionCommand(VAddr addr, u64 size)
-        : addr{addr}, size{size} {}
-
-    const VAddr addr;
-    const u64 size;
-};
-
-using CommandData = std::variant<SubmitListCommand, SwapBuffersCommand, FlushRegionCommand,
-                                 InvalidateRegionCommand, FlushAndInvalidateRegionCommand>;
-
-/// Struct used to synchronize the GPU thread
-struct SynchState final {
-    std::atomic<bool> is_running{true};
-    std::atomic<bool> is_idle{true};
-    std::condition_variable signal_condition;
-    std::mutex signal_mutex;
-    std::condition_variable idle_condition;
-    std::mutex idle_mutex;
-
-    // We use two queues for sending commands to the GPU thread, one for writing (push_queue) to and
-    // one for reading from (pop_queue). These are swapped whenever the current pop_queue becomes
-    // empty. This allows for efficient thread-safe access, as it does not require any copies.
-
-    using CommandQueue = std::queue<CommandData>;
-    std::array<CommandQueue, 2> command_queues;
-    CommandQueue* push_queue{&command_queues[0]};
-    CommandQueue* pop_queue{&command_queues[1]};
-
-    void UpdateIdleState() {
-        std::lock_guard<std::mutex> lock{idle_mutex};
-        is_idle = command_queues[0].empty() && command_queues[1].empty();
-    }
-};
-
-/// Class used to manage the GPU thread
-class ThreadManager final {
-public:
-    explicit ThreadManager(VideoCore::RendererBase& renderer, Tegra::DmaPusher& dma_pusher);
-    ~ThreadManager();
-
-    /// Push GPU command entries to be processed
-    void SubmitList(Tegra::CommandList&& entries);
-
-    /// Swap buffers (render frame)
-    void SwapBuffers(
-        std::optional<std::reference_wrapper<const Tegra::FramebufferConfig>> framebuffer);
-
-    /// Notify rasterizer that any caches of the specified region should be flushed to Switch memory
-    void FlushRegion(VAddr addr, u64 size);
-
-    /// Notify rasterizer that any caches of the specified region should be invalidated
-    void InvalidateRegion(VAddr addr, u64 size);
-
-    /// Notify rasterizer that any caches of the specified region should be flushed and invalidated
-    void FlushAndInvalidateRegion(VAddr addr, u64 size);
-
-    /// Waits the caller until the GPU thread is idle, used for synchronization
-    void WaitForIdle();
-
-private:
-    /// Pushes a command to be executed by the GPU thread
-    void PushCommand(CommandData&& command_data, bool wait_for_idle, bool allow_on_cpu);
-
-    /// Returns true if this is called by the GPU thread
-    bool IsGpuThread() const {
-        return std::this_thread::get_id() == thread_id;
-    }
-
-private:
-    SynchState state;
-    std::thread thread;
-    std::thread::id thread_id;
-    VideoCore::RendererBase& renderer;
-    Tegra::DmaPusher& dma_pusher;
-};
-
-} // namespace VideoCommon::GPUThread
@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-#include "common/logging/log.h"
 #include "core/frontend/emu_window.h"
 #include "core/settings.h"
 #include "video_core/renderer_base.h"
@@ -749,7 +749,11 @@ void RasterizerOpenGL::FlushAll() {}

 void RasterizerOpenGL::FlushRegion(VAddr addr, u64 size) {
    MICROPROFILE_SCOPE(OpenGL_CacheManagement);
-    res_cache.FlushRegion(addr, size);
+
+    if (Settings::values.use_accurate_gpu_emulation) {
+        // Only flush if use_accurate_gpu_emulation is enabled, as it incurs a performance hit
+        res_cache.FlushRegion(addr, size);
+    }
 }

 void RasterizerOpenGL::InvalidateRegion(VAddr addr, u64 size) {
@@ -21,7 +21,7 @@
 #include "video_core/renderer_opengl/gl_rasterizer_cache.h"
 #include "video_core/renderer_opengl/utils.h"
 #include "video_core/surface.h"
-#include "video_core/textures/convert.h"
+#include "video_core/textures/astc.h"
 #include "video_core/textures/decoders.h"

 namespace OpenGL {
@@ -597,6 +597,103 @@ CachedSurface::CachedSurface(const SurfaceParams& params)
    }
 }

+static void ConvertS8Z24ToZ24S8(std::vector<u8>& data, u32 width, u32 height, bool reverse) {
+    union S8Z24 {
+        BitField<0, 24, u32> z24;
+        BitField<24, 8, u32> s8;
+    };
+    static_assert(sizeof(S8Z24) == 4, "S8Z24 is incorrect size");
+
+    union Z24S8 {
+        BitField<0, 8, u32> s8;
+        BitField<8, 24, u32> z24;
+    };
+    static_assert(sizeof(Z24S8) == 4, "Z24S8 is incorrect size");
+
+    S8Z24 s8z24_pixel{};
+    Z24S8 z24s8_pixel{};
+    constexpr auto bpp{GetBytesPerPixel(PixelFormat::S8Z24)};
+    for (std::size_t y = 0; y < height; ++y) {
+        for (std::size_t x = 0; x < width; ++x) {
+            const std::size_t offset{bpp * (y * width + x)};
+            if (reverse) {
+                std::memcpy(&z24s8_pixel, &data[offset], sizeof(Z24S8));
+                s8z24_pixel.s8.Assign(z24s8_pixel.s8);
+                s8z24_pixel.z24.Assign(z24s8_pixel.z24);
+                std::memcpy(&data[offset], &s8z24_pixel, sizeof(S8Z24));
+            } else {
+                std::memcpy(&s8z24_pixel, &data[offset], sizeof(S8Z24));
+                z24s8_pixel.s8.Assign(s8z24_pixel.s8);
+                z24s8_pixel.z24.Assign(s8z24_pixel.z24);
+                std::memcpy(&data[offset], &z24s8_pixel, sizeof(Z24S8));
+            }
+        }
+    }
+}
+
+/**
+ * Helper function to perform software conversion (as needed) when loading a buffer from Switch
+ * memory. This is for Maxwell pixel formats that cannot be represented as-is in OpenGL or with
+ * typical desktop GPUs.
+ */
+static void ConvertFormatAsNeeded_LoadGLBuffer(std::vector<u8>& data, PixelFormat pixel_format,
+                                               u32 width, u32 height, u32 depth) {
+    switch (pixel_format) {
+    case PixelFormat::ASTC_2D_4X4:
+    case PixelFormat::ASTC_2D_8X8:
+    case PixelFormat::ASTC_2D_8X5:
+    case PixelFormat::ASTC_2D_5X4:
+    case PixelFormat::ASTC_2D_5X5:
+    case PixelFormat::ASTC_2D_4X4_SRGB:
+    case PixelFormat::ASTC_2D_8X8_SRGB:
+    case PixelFormat::ASTC_2D_8X5_SRGB:
+    case PixelFormat::ASTC_2D_5X4_SRGB:
+    case PixelFormat::ASTC_2D_5X5_SRGB:
+    case PixelFormat::ASTC_2D_10X8:
+    case PixelFormat::ASTC_2D_10X8_SRGB: {
+        // Convert ASTC pixel formats to RGBA8, as most desktop GPUs do not support ASTC.
+        u32 block_width{};
+        u32 block_height{};
+        std::tie(block_width, block_height) = GetASTCBlockSize(pixel_format);
+        data =
+            Tegra::Texture::ASTC::Decompress(data, width, height, depth, block_width, block_height);
+        break;
+    }
+    case PixelFormat::S8Z24:
+        // Convert the S8Z24 depth format to Z24S8, as OpenGL does not support S8Z24.
+        ConvertS8Z24ToZ24S8(data, width, height, false);
+        break;
+    }
+}
+
+/**
+ * Helper function to perform software conversion (as needed) when flushing a buffer from OpenGL to
+ * Switch memory. This is for Maxwell pixel formats that cannot be represented as-is in OpenGL or
+ * with typical desktop GPUs.
+ */
+static void ConvertFormatAsNeeded_FlushGLBuffer(std::vector<u8>& data, PixelFormat pixel_format,
+                                                u32 width, u32 height) {
+    switch (pixel_format) {
+    case PixelFormat::ASTC_2D_4X4:
+    case PixelFormat::ASTC_2D_8X8:
+    case PixelFormat::ASTC_2D_4X4_SRGB:
+    case PixelFormat::ASTC_2D_8X8_SRGB:
+    case PixelFormat::ASTC_2D_5X5:
+    case PixelFormat::ASTC_2D_5X5_SRGB:
+    case PixelFormat::ASTC_2D_10X8:
+    case PixelFormat::ASTC_2D_10X8_SRGB: {
+        LOG_CRITICAL(HW_GPU, "Conversion of format {} after texture flushing is not implemented",
+                     static_cast<u32>(pixel_format));
+        UNREACHABLE();
+        break;
+    }
+    case PixelFormat::S8Z24:
+        // Convert the Z24S8 depth format to S8Z24, as OpenGL does not support S8Z24.
+        ConvertS8Z24ToZ24S8(data, width, height, true);
+        break;
+    }
+}
+
 MICROPROFILE_DEFINE(OpenGL_SurfaceLoad, "OpenGL", "Surface Load", MP_RGB(128, 192, 64));
 void CachedSurface::LoadGLBuffer() {
    MICROPROFILE_SCOPE(OpenGL_SurfaceLoad);
@@ -625,16 +722,8 @@ void CachedSurface::LoadGLBuffer() {
        }
    }
    for (u32 i = 0; i < params.max_mip_level; i++) {
-        const u32 width = params.MipWidth(i);
-        const u32 height = params.MipHeight(i);
-        const u32 depth = params.MipDepth(i);
-        if (VideoCore::Surface::IsPixelFormatASTC(params.pixel_format)) {
-            // Reserve size for RGBA8 conversion
-            constexpr std::size_t rgba_bpp = 4;
-            gl_buffer[i].resize(std::max(gl_buffer[i].size(), width * height * depth * rgba_bpp));
-        }
-        Tegra::Texture::ConvertFromGuestToHost(gl_buffer[i].data(), params.pixel_format, width,
-                                               height, depth, true, true);
+        ConvertFormatAsNeeded_LoadGLBuffer(gl_buffer[i], params.pixel_format, params.MipWidth(i),
+                                           params.MipHeight(i), params.MipDepth(i));
    }
 }

@@ -657,8 +746,8 @@ void CachedSurface::FlushGLBuffer() {
    glGetTextureImage(texture.handle, 0, tuple.format, tuple.type,
                      static_cast<GLsizei>(gl_buffer[0].size()), gl_buffer[0].data());
    glPixelStorei(GL_PACK_ROW_LENGTH, 0);
-    Tegra::Texture::ConvertFromHostToGuest(gl_buffer[0].data(), params.pixel_format, params.width,
-                                           params.height, params.depth, true, true);
+    ConvertFormatAsNeeded_FlushGLBuffer(gl_buffer[0], params.pixel_format, params.width,
+                                        params.height);
    const u8* const texture_src_data = Memory::GetPointer(params.addr);
    ASSERT(texture_src_data);
    if (params.is_tiled) {
@@ -244,21 +244,6 @@ void RendererOpenGL::InitOpenGLObjects() {
    LoadColorToActiveGLTexture(0, 0, 0, 0, screen_info.texture);
 }

-void RendererOpenGL::AddTelemetryFields() {
-    const char* const gl_version{reinterpret_cast<char const*>(glGetString(GL_VERSION))};
-    const char* const gpu_vendor{reinterpret_cast<char const*>(glGetString(GL_VENDOR))};
-    const char* const gpu_model{reinterpret_cast<char const*>(glGetString(GL_RENDERER))};
-
-    LOG_INFO(Render_OpenGL, "GL_VERSION: {}", gl_version);
-    LOG_INFO(Render_OpenGL, "GL_VENDOR: {}", gpu_vendor);
-    LOG_INFO(Render_OpenGL, "GL_RENDERER: {}", gpu_model);
-
-    auto& telemetry_session = system.TelemetrySession();
-    telemetry_session.AddField(Telemetry::FieldType::UserSystem, "GPU_Vendor", gpu_vendor);
-    telemetry_session.AddField(Telemetry::FieldType::UserSystem, "GPU_Model", gpu_model);
-    telemetry_session.AddField(Telemetry::FieldType::UserSystem, "GPU_OpenGL_Version", gl_version);
-}
-
 void RendererOpenGL::CreateRasterizer() {
    if (rasterizer) {
        return;
@@ -481,7 +466,17 @@ bool RendererOpenGL::Init() {
        glDebugMessageCallback(DebugHandler, nullptr);
    }

-    AddTelemetryFields();
+    const char* gl_version{reinterpret_cast<char const*>(glGetString(GL_VERSION))};
+    const char* gpu_vendor{reinterpret_cast<char const*>(glGetString(GL_VENDOR))};
+    const char* gpu_model{reinterpret_cast<char const*>(glGetString(GL_RENDERER))};
+
+    LOG_INFO(Render_OpenGL, "GL_VERSION: {}", gl_version);
+    LOG_INFO(Render_OpenGL, "GL_VENDOR: {}", gpu_vendor);
+    LOG_INFO(Render_OpenGL, "GL_RENDERER: {}", gpu_model);
+
+    Core::Telemetry().AddField(Telemetry::FieldType::UserSystem, "GPU_Vendor", gpu_vendor);
+    Core::Telemetry().AddField(Telemetry::FieldType::UserSystem, "GPU_Model", gpu_model);
+    Core::Telemetry().AddField(Telemetry::FieldType::UserSystem, "GPU_OpenGL_Version", gl_version);

    if (!GLAD_GL_VERSION_4_3) {
        return false;
@@ -60,7 +60,6 @@ public:

 private:
    void InitOpenGLObjects();
-    void AddTelemetryFields();
    void CreateRasterizer();

    void ConfigureFramebufferTexture(TextureInfo& texture,
@@ -8,7 +8,7 @@
 #include <tuple>

 #include "common/alignment.h"
-#include "common/assert.h"
+#include "core/core.h"
 #include "core/memory.h"
 #include "video_core/renderer_vulkan/declarations.h"
 #include "video_core/renderer_vulkan/vk_buffer_cache.h"
@@ -89,6 +89,8 @@ PixelFormat PixelFormatFromDepthFormat(Tegra::DepthFormat format) {

 PixelFormat PixelFormatFromRenderTargetFormat(Tegra::RenderTargetFormat format) {
    switch (format) {
+        // TODO (Hexagon12): Converting SRGBA to RGBA is a hack and doesn't completely correct the
+        // gamma.
    case Tegra::RenderTargetFormat::RGBA8_SRGB:
        return PixelFormat::RGBA8_SRGB;
    case Tegra::RenderTargetFormat::RGBA8_UNORM:
@@ -23,12 +23,28 @@

 #include "video_core/textures/astc.h"

-class InputBitStream {
+class BitStream {
 public:
-    explicit InputBitStream(const unsigned char* ptr, int nBits = 0, int start_offset = 0)
+    explicit BitStream(unsigned char* ptr, int nBits = 0, int start_offset = 0)
        : m_NumBits(nBits), m_CurByte(ptr), m_NextBit(start_offset % 8) {}

-    ~InputBitStream() = default;
+    ~BitStream() = default;
+
+    int GetBitsWritten() const {
+        return m_BitsWritten;
+    }
+
+    void WriteBitsR(unsigned int val, unsigned int nBits) {
+        for (unsigned int i = 0; i < nBits; i++) {
+            WriteBit((val >> (nBits - i - 1)) & 1);
+        }
+    }
+
+    void WriteBits(unsigned int val, unsigned int nBits) {
+        for (unsigned int i = 0; i < nBits; i++) {
+            WriteBit((val >> i) & 1);
+        }
+    }

    int GetBitsRead() const {
        return m_BitsRead;
@@ -54,38 +70,6 @@ public:
        return ret;
    }

-private:
-    const int m_NumBits;
-    const unsigned char* m_CurByte;
-    int m_NextBit = 0;
-    int m_BitsRead = 0;
-
-    bool done = false;
-};
-
-class OutputBitStream {
-public:
-    explicit OutputBitStream(unsigned char* ptr, int nBits = 0, int start_offset = 0)
-        : m_NumBits(nBits), m_CurByte(ptr), m_NextBit(start_offset % 8) {}
-
-    ~OutputBitStream() = default;
-
-    int GetBitsWritten() const {
-        return m_BitsWritten;
-    }
-
-    void WriteBitsR(unsigned int val, unsigned int nBits) {
-        for (unsigned int i = 0; i < nBits; i++) {
-            WriteBit((val >> (nBits - i - 1)) & 1);
-        }
-    }
-
-    void WriteBits(unsigned int val, unsigned int nBits) {
-        for (unsigned int i = 0; i < nBits; i++) {
-            WriteBit((val >> i) & 1);
-        }
-    }
-
 private:
    void WriteBit(int b) {

@@ -254,8 +238,8 @@ public:
    // Fills result with the values that are encoded in the given
    // bitstream. We must know beforehand what the maximum possible
    // value is, and how many values we're decoding.
-    static void DecodeIntegerSequence(std::vector<IntegerEncodedValue>& result,
-                                      InputBitStream& bits, uint32_t maxRange, uint32_t nValues) {
+    static void DecodeIntegerSequence(std::vector<IntegerEncodedValue>& result, BitStream& bits,
+                                      uint32_t maxRange, uint32_t nValues) {
        // Determine encoding parameters
        IntegerEncodedValue val = IntegerEncodedValue::CreateEncoding(maxRange);

@@ -283,7 +267,7 @@ public:
    }

 private:
-    static void DecodeTritBlock(InputBitStream& bits, std::vector<IntegerEncodedValue>& result,
+    static void DecodeTritBlock(BitStream& bits, std::vector<IntegerEncodedValue>& result,
                                uint32_t nBitsPerValue) {
        // Implement the algorithm in section C.2.12
        uint32_t m[5];
@@ -343,7 +327,7 @@ private:
        }
    }

-    static void DecodeQuintBlock(InputBitStream& bits, std::vector<IntegerEncodedValue>& result,
+    static void DecodeQuintBlock(BitStream& bits, std::vector<IntegerEncodedValue>& result,
                                 uint32_t nBitsPerValue) {
        // Implement the algorithm in section C.2.12
        uint32_t m[3];
@@ -422,7 +406,7 @@ struct TexelWeightParams {
    }
 };

-static TexelWeightParams DecodeBlockInfo(InputBitStream& strm) {
+static TexelWeightParams DecodeBlockInfo(BitStream& strm) {
    TexelWeightParams params;

    // Read the entire block mode all at once
@@ -621,7 +605,7 @@ static TexelWeightParams DecodeBlockInfo(InputBitStream& strm) {
    return params;
 }

-static void FillVoidExtentLDR(InputBitStream& strm, uint32_t* const outBuf, uint32_t blockWidth,
+static void FillVoidExtentLDR(BitStream& strm, uint32_t* const outBuf, uint32_t blockWidth,
                              uint32_t blockHeight) {
    // Don't actually care about the void extent, just read the bits...
    for (int i = 0; i < 4; ++i) {
@@ -837,7 +821,7 @@ static void DecodeColorValues(uint32_t* out, uint8_t* data, const uint32_t* mode

    // We now have enough to decode our integer sequence.
    std::vector<IntegerEncodedValue> decodedColorValues;
-    InputBitStream colorStream(data);
+    BitStream colorStream(data);
    IntegerEncodedValue::DecodeIntegerSequence(decodedColorValues, colorStream, range, nValues);

    // Once we have the decoded values, we need to dequantize them to the 0-255 range
@@ -1381,9 +1365,9 @@ static void ComputeEndpoints(Pixel& ep1, Pixel& ep2, const uint32_t*& colorValue
 #undef READ_INT_VALUES
 }

-static void DecompressBlock(const uint8_t inBuf[16], const uint32_t blockWidth,
+static void DecompressBlock(uint8_t inBuf[16], const uint32_t blockWidth,
                            const uint32_t blockHeight, uint32_t* outBuf) {
-    InputBitStream strm(inBuf);
+    BitStream strm(inBuf);
    TexelWeightParams weightParams = DecodeBlockInfo(strm);

    // Was there an error?
@@ -1437,7 +1421,7 @@ static void DecompressBlock(const uint8_t inBuf[16], const uint32_t blockWidth,
    // Define color data.
    uint8_t colorEndpointData[16];
    memset(colorEndpointData, 0, sizeof(colorEndpointData));
-    OutputBitStream colorEndpointStream(colorEndpointData, 16 * 8, 0);
+    BitStream colorEndpointStream(colorEndpointData, 16 * 8, 0);

    // Read extra config data...
    uint32_t baseCEM = 0;
@@ -1565,7 +1549,7 @@ static void DecompressBlock(const uint8_t inBuf[16], const uint32_t blockWidth,
    memset(texelWeightData + clearByteStart, 0, 16 - clearByteStart);

    std::vector<IntegerEncodedValue> texelWeightValues;
-    InputBitStream weightStream(texelWeightData);
+    BitStream weightStream(texelWeightData);

    IntegerEncodedValue::DecodeIntegerSequence(texelWeightValues, weightStream,
                                               weightParams.m_MaxWeight,
@@ -1613,7 +1597,7 @@ static void DecompressBlock(const uint8_t inBuf[16], const uint32_t blockWidth,

 namespace Tegra::Texture::ASTC {

-std::vector<uint8_t> Decompress(const uint8_t* data, uint32_t width, uint32_t height,
+std::vector<uint8_t> Decompress(std::vector<uint8_t>& data, uint32_t width, uint32_t height,
                                uint32_t depth, uint32_t block_width, uint32_t block_height) {
    uint32_t blockIdx = 0;
    std::vector<uint8_t> outData(height * width * depth * 4);
@@ -1621,7 +1605,7 @@ std::vector<uint8_t> Decompress(const uint8_t* data, uint32_t width, uint32_t he
        for (uint32_t j = 0; j < height; j += block_height) {
            for (uint32_t i = 0; i < width; i += block_width) {

-                const uint8_t* blockPtr = data + blockIdx * 16;
+                uint8_t* blockPtr = data.data() + blockIdx * 16;

                // Blocks can be at most 12x12
                uint32_t uncompData[144];
@@ -9,7 +9,7 @@

 namespace Tegra::Texture::ASTC {

-std::vector<uint8_t> Decompress(const uint8_t* data, uint32_t width, uint32_t height,
+std::vector<uint8_t> Decompress(std::vector<uint8_t>& data, uint32_t width, uint32_t height,
                                uint32_t depth, uint32_t block_width, uint32_t block_height);

 } // namespace Tegra::Texture::ASTC
@@ -1,92 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <cstring>
-#include <tuple>
-#include <vector>
-
-#include "common/assert.h"
-#include "common/common_types.h"
-#include "common/logging/log.h"
-#include "video_core/textures/astc.h"
-#include "video_core/textures/convert.h"
-
-namespace Tegra::Texture {
-
-using VideoCore::Surface::PixelFormat;
-
-template <bool reverse>
-void SwapS8Z24ToZ24S8(u8* data, u32 width, u32 height) {
-    union S8Z24 {
-        BitField<0, 24, u32> z24;
-        BitField<24, 8, u32> s8;
-    };
-    static_assert(sizeof(S8Z24) == 4, "S8Z24 is incorrect size");
-
-    union Z24S8 {
-        BitField<0, 8, u32> s8;
-        BitField<8, 24, u32> z24;
-    };
-    static_assert(sizeof(Z24S8) == 4, "Z24S8 is incorrect size");
-
-    S8Z24 s8z24_pixel{};
-    Z24S8 z24s8_pixel{};
-    constexpr auto bpp{
-        VideoCore::Surface::GetBytesPerPixel(VideoCore::Surface::PixelFormat::S8Z24)};
-    for (std::size_t y = 0; y < height; ++y) {
-        for (std::size_t x = 0; x < width; ++x) {
-            const std::size_t offset{bpp * (y * width + x)};
-            if constexpr (reverse) {
-                std::memcpy(&z24s8_pixel, &data[offset], sizeof(Z24S8));
-                s8z24_pixel.s8.Assign(z24s8_pixel.s8);
-                s8z24_pixel.z24.Assign(z24s8_pixel.z24);
-                std::memcpy(&data[offset], &s8z24_pixel, sizeof(S8Z24));
-            } else {
-                std::memcpy(&s8z24_pixel, &data[offset], sizeof(S8Z24));
-                z24s8_pixel.s8.Assign(s8z24_pixel.s8);
-                z24s8_pixel.z24.Assign(s8z24_pixel.z24);
-                std::memcpy(&data[offset], &z24s8_pixel, sizeof(Z24S8));
-            }
-        }
-    }
-}
-
-static void ConvertS8Z24ToZ24S8(u8* data, u32 width, u32 height) {
-    SwapS8Z24ToZ24S8<false>(data, width, height);
-}
-
-static void ConvertZ24S8ToS8Z24(u8* data, u32 width, u32 height) {
-    SwapS8Z24ToZ24S8<true>(data, width, height);
-}
-
-void ConvertFromGuestToHost(u8* data, PixelFormat pixel_format, u32 width, u32 height, u32 depth,
-                            bool convert_astc, bool convert_s8z24) {
-    if (convert_astc && IsPixelFormatASTC(pixel_format)) {
-        // Convert ASTC pixel formats to RGBA8, as most desktop GPUs do not support ASTC.
-        u32 block_width{};
-        u32 block_height{};
-        std::tie(block_width, block_height) = GetASTCBlockSize(pixel_format);
-        const std::vector<u8> rgba8_data =
-            Tegra::Texture::ASTC::Decompress(data, width, height, depth, block_width, block_height);
-        std::copy(rgba8_data.begin(), rgba8_data.end(), data);
-
-    } else if (convert_s8z24 && pixel_format == PixelFormat::S8Z24) {
-        Tegra::Texture::ConvertS8Z24ToZ24S8(data, width, height);
-    }
-}
-
-void ConvertFromHostToGuest(u8* data, PixelFormat pixel_format, u32 width, u32 height, u32 depth,
-                            bool convert_astc, bool convert_s8z24) {
-    if (convert_astc && IsPixelFormatASTC(pixel_format)) {
-        LOG_CRITICAL(HW_GPU, "Conversion of format {} after texture flushing is not implemented",
-                     static_cast<u32>(pixel_format));
-        UNREACHABLE();
-
-    } else if (convert_s8z24 && pixel_format == PixelFormat::S8Z24) {
-        Tegra::Texture::ConvertZ24S8ToS8Z24(data, width, height);
-    }
-}
-
-} // namespace Tegra::Texture
@@ -1,18 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-#include "video_core/surface.h"
-
-namespace Tegra::Texture {
-
-void ConvertFromGuestToHost(u8* data, VideoCore::Surface::PixelFormat pixel_format, u32 width,
-                            u32 height, u32 depth, bool convert_astc, bool convert_s8z24);
-
-void ConvertFromHostToGuest(u8* data, VideoCore::Surface::PixelFormat pixel_format, u32 width,
-                            u32 height, u32 depth, bool convert_astc, bool convert_s8z24);
-
-} // namespace Tegra::Texture
@@ -103,8 +103,8 @@ void FastProcessBlock(u8* const swizzled_data, u8* const unswizzled_data, const
                const u32 swizzle_offset{y_address + table[(xb / fast_swizzle_align) % 4]};
                const u32 out_x = xb * out_bytes_per_pixel / bytes_per_pixel;
                const u32 pixel_index{out_x + pixel_base};
-                data_ptrs[unswizzle ? 1 : 0] = swizzled_data + swizzle_offset;
-                data_ptrs[unswizzle ? 0 : 1] = unswizzled_data + pixel_index;
+                data_ptrs[unswizzle] = swizzled_data + swizzle_offset;
+                data_ptrs[!unswizzle] = unswizzled_data + pixel_index;
                std::memcpy(data_ptrs[0], data_ptrs[1], fast_swizzle_align);
            }
            pixel_base += stride_x;
@@ -154,7 +154,7 @@ void SwizzledData(u8* const swizzled_data, u8* const unswizzled_data, const bool
            for (u32 xb = 0; xb < blocks_on_x; xb++) {
                const u32 x_start = xb * block_x_elements;
                const u32 x_end = std::min(width, x_start + block_x_elements);
-                if constexpr (fast) {
+                if (fast) {
                    FastProcessBlock(swizzled_data, unswizzled_data, unswizzle, x_start, y_start,
                                     z_start, x_end, y_end, z_end, tile_offset, xy_block_size,
                                     layer_z, stride_x, bytes_per_pixel, out_bytes_per_pixel);
@@ -16,13 +16,16 @@ inline std::size_t GetGOBSize() {
    return 512;
 }

-/// Unswizzles a swizzled texture without changing its format.
+/**
+ * Unswizzles a swizzled texture without changing its format.
+ */
 void UnswizzleTexture(u8* unswizzled_data, VAddr address, u32 tile_size_x, u32 tile_size_y,
                      u32 bytes_per_pixel, u32 width, u32 height, u32 depth,
                      u32 block_height = TICEntry::DefaultBlockHeight,
                      u32 block_depth = TICEntry::DefaultBlockHeight, u32 width_spacing = 0);
-
-/// Unswizzles a swizzled texture without changing its format.
+/**
+ * Unswizzles a swizzled texture without changing its format.
+ */
 std::vector<u8> UnswizzleTexture(VAddr address, u32 tile_size_x, u32 tile_size_y,
                                 u32 bytes_per_pixel, u32 width, u32 height, u32 depth,
                                 u32 block_height = TICEntry::DefaultBlockHeight,
@@ -34,11 +37,15 @@ void CopySwizzledData(u32 width, u32 height, u32 depth, u32 bytes_per_pixel,
                      u32 out_bytes_per_pixel, u8* swizzled_data, u8* unswizzled_data,
                      bool unswizzle, u32 block_height, u32 block_depth, u32 width_spacing);

-/// Decodes an unswizzled texture into a A8R8G8B8 texture.
+/**
+ * Decodes an unswizzled texture into a A8R8G8B8 texture.
+ */
 std::vector<u8> DecodeTexture(const std::vector<u8>& texture_data, TextureFormat format, u32 width,
                              u32 height);

-/// This function calculates the correct size of a texture depending if it's tiled or not.
+/**
+ * This function calculates the correct size of a texture depending if it's tiled or not.
+ */
 std::size_t CalculateSize(bool tiled, u32 bytes_per_pixel, u32 width, u32 height, u32 depth,
                          u32 block_height, u32 block_depth);

@@ -46,7 +53,6 @@ std::size_t CalculateSize(bool tiled, u32 bytes_per_pixel, u32 width, u32 height
 void SwizzleSubrect(u32 subrect_width, u32 subrect_height, u32 source_pitch, u32 swizzled_width,
                    u32 bytes_per_pixel, VAddr swizzled_data, VAddr unswizzled_data,
                    u32 block_height);
-
 /// Copies a tiled subrectangle into a linear surface.
 void UnswizzleSubrect(u32 subrect_width, u32 subrect_height, u32 dest_pitch, u32 swizzled_width,
                      u32 bytes_per_pixel, VAddr swizzled_data, VAddr unswizzled_data,
@@ -20,7 +20,10 @@
 EmuThread::EmuThread(GRenderWindow* render_window) : render_window(render_window) {}

 void EmuThread::run() {
-    render_window->MakeCurrent();
+    if (!Settings::values.use_multi_core) {
+        // Single core mode must acquire OpenGL context for entire emulation session
+        render_window->MakeCurrent();
+    }

    MicroProfileOnThreadCreate("EmuThread");

@@ -35,11 +38,6 @@ void EmuThread::run() {

    emit LoadProgress(VideoCore::LoadCallbackStage::Complete, 0, 0);

-    if (Settings::values.use_asynchronous_gpu_emulation) {
-        // Release OpenGL context for the GPU thread
-        render_window->DoneCurrent();
-    }
-
    // holds whether the cpu was running during the last iteration,
    // so that the DebugModeLeft signal can be emitted before the
    // next execution step
@@ -53,8 +53,8 @@ void CompatDB::Submit() {
    case CompatDBPage::Final:
        back();
        LOG_DEBUG(Frontend, "Compatibility Rating: {}", compatibility->checkedId());
-        Core::System::GetInstance().TelemetrySession().AddField(
-            Telemetry::FieldType::UserFeedback, "Compatibility", compatibility->checkedId());
+        Core::Telemetry().AddField(Telemetry::FieldType::UserFeedback, "Compatibility",
+                                   compatibility->checkedId());

        button(NextButton)->setEnabled(false);
        button(NextButton)->setText(tr("Submitting"));
@@ -209,7 +209,7 @@ void Config::ReadPlayerValues() {
    for (std::size_t p = 0; p < Settings::values.players.size(); ++p) {
        auto& player = Settings::values.players[p];

-        player.connected = ReadSetting(QString("player_%1_connected").arg(p), false).toBool();
+        player.connected = qt_config->value(QString("player_%1_connected").arg(p), false).toBool();

        player.type = static_cast<Settings::ControllerType>(
            qt_config
@@ -269,7 +269,7 @@ void Config::ReadPlayerValues() {
 }

 void Config::ReadDebugValues() {
-    Settings::values.debug_pad_enabled = ReadSetting("debug_pad_enabled", false).toBool();
+    Settings::values.debug_pad_enabled = qt_config->value("debug_pad_enabled", false).toBool();
    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
        std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
        Settings::values.debug_pad_buttons[i] =
@@ -298,7 +298,7 @@ void Config::ReadDebugValues() {
 }

 void Config::ReadKeyboardValues() {
-    Settings::values.keyboard_enabled = ReadSetting("keyboard_enabled", false).toBool();
+    Settings::values.keyboard_enabled = qt_config->value("keyboard_enabled", false).toBool();

    std::transform(default_keyboard_keys.begin(), default_keyboard_keys.end(),
                   Settings::values.keyboard_keys.begin(), InputCommon::GenerateKeyboardParam);
@@ -311,7 +311,7 @@ void Config::ReadKeyboardValues() {
 }

 void Config::ReadMouseValues() {
-    Settings::values.mouse_enabled = ReadSetting("mouse_enabled", false).toBool();
+    Settings::values.mouse_enabled = qt_config->value("mouse_enabled", false).toBool();

    for (int i = 0; i < Settings::NativeMouseButton::NumMouseButtons; ++i) {
        std::string default_param = InputCommon::GenerateKeyboardParam(default_mouse_buttons[i]);
@@ -327,14 +327,16 @@ void Config::ReadMouseValues() {
 }

 void Config::ReadTouchscreenValues() {
-    Settings::values.touchscreen.enabled = ReadSetting("touchscreen_enabled", true).toBool();
+    Settings::values.touchscreen.enabled = qt_config->value("touchscreen_enabled", true).toBool();
    Settings::values.touchscreen.device =
-        ReadSetting("touchscreen_device", "engine:emu_window").toString().toStdString();
+        qt_config->value("touchscreen_device", "engine:emu_window").toString().toStdString();

-    Settings::values.touchscreen.finger = ReadSetting("touchscreen_finger", 0).toUInt();
-    Settings::values.touchscreen.rotation_angle = ReadSetting("touchscreen_angle", 0).toUInt();
-    Settings::values.touchscreen.diameter_x = ReadSetting("touchscreen_diameter_x", 15).toUInt();
-    Settings::values.touchscreen.diameter_y = ReadSetting("touchscreen_diameter_y", 15).toUInt();
+    Settings::values.touchscreen.finger = qt_config->value("touchscreen_finger", 0).toUInt();
+    Settings::values.touchscreen.rotation_angle = qt_config->value("touchscreen_angle", 0).toUInt();
+    Settings::values.touchscreen.diameter_x =
+        qt_config->value("touchscreen_diameter_x", 15).toUInt();
+    Settings::values.touchscreen.diameter_y =
+        qt_config->value("touchscreen_diameter_y", 15).toUInt();
    qt_config->endGroup();
 }

@@ -355,41 +357,40 @@ void Config::ReadValues() {
    ReadTouchscreenValues();

    Settings::values.motion_device =
-        ReadSetting("motion_device", "engine:motion_emu,update_period:100,sensitivity:0.01")
+        qt_config->value("motion_device", "engine:motion_emu,update_period:100,sensitivity:0.01")
            .toString()
            .toStdString();

    qt_config->beginGroup("Core");
-    Settings::values.use_cpu_jit = ReadSetting("use_cpu_jit", true).toBool();
-    Settings::values.use_multi_core = ReadSetting("use_multi_core", false).toBool();
+    Settings::values.use_cpu_jit = qt_config->value("use_cpu_jit", true).toBool();
+    Settings::values.use_multi_core = qt_config->value("use_multi_core", false).toBool();
    qt_config->endGroup();

    qt_config->beginGroup("Renderer");
-    Settings::values.resolution_factor = ReadSetting("resolution_factor", 1.0).toFloat();
-    Settings::values.use_frame_limit = ReadSetting("use_frame_limit", true).toBool();
-    Settings::values.frame_limit = ReadSetting("frame_limit", 100).toInt();
-    Settings::values.use_disk_shader_cache = ReadSetting("use_disk_shader_cache", true).toBool();
+    Settings::values.resolution_factor = qt_config->value("resolution_factor", 1.0).toFloat();
+    Settings::values.use_frame_limit = qt_config->value("use_frame_limit", true).toBool();
+    Settings::values.frame_limit = qt_config->value("frame_limit", 100).toInt();
+    Settings::values.use_disk_shader_cache =
+        qt_config->value("use_disk_shader_cache", false).toBool();
    Settings::values.use_accurate_gpu_emulation =
-        ReadSetting("use_accurate_gpu_emulation", false).toBool();
-    Settings::values.use_asynchronous_gpu_emulation =
-        ReadSetting("use_asynchronous_gpu_emulation", false).toBool();
+        qt_config->value("use_accurate_gpu_emulation", false).toBool();

-    Settings::values.bg_red = ReadSetting("bg_red", 0.0).toFloat();
-    Settings::values.bg_green = ReadSetting("bg_green", 0.0).toFloat();
-    Settings::values.bg_blue = ReadSetting("bg_blue", 0.0).toFloat();
+    Settings::values.bg_red = qt_config->value("bg_red", 0.0).toFloat();
+    Settings::values.bg_green = qt_config->value("bg_green", 0.0).toFloat();
+    Settings::values.bg_blue = qt_config->value("bg_blue", 0.0).toFloat();
    qt_config->endGroup();

    qt_config->beginGroup("Audio");
-    Settings::values.sink_id = ReadSetting("output_engine", "auto").toString().toStdString();
+    Settings::values.sink_id = qt_config->value("output_engine", "auto").toString().toStdString();
    Settings::values.enable_audio_stretching =
-        ReadSetting("enable_audio_stretching", true).toBool();
+        qt_config->value("enable_audio_stretching", true).toBool();
    Settings::values.audio_device_id =
-        ReadSetting("output_device", "auto").toString().toStdString();
-    Settings::values.volume = ReadSetting("volume", 1).toFloat();
+        qt_config->value("output_device", "auto").toString().toStdString();
+    Settings::values.volume = qt_config->value("volume", 1).toFloat();
    qt_config->endGroup();

    qt_config->beginGroup("Data Storage");
-    Settings::values.use_virtual_sd = ReadSetting("use_virtual_sd", true).toBool();
+    Settings::values.use_virtual_sd = qt_config->value("use_virtual_sd", true).toBool();
    FileUtil::GetUserPath(
        FileUtil::UserPath::NANDDir,
        qt_config
@@ -407,30 +408,30 @@ void Config::ReadValues() {
    qt_config->endGroup();

    qt_config->beginGroup("Core");
-    Settings::values.use_cpu_jit = ReadSetting("use_cpu_jit", true).toBool();
-    Settings::values.use_multi_core = ReadSetting("use_multi_core", false).toBool();
+    Settings::values.use_cpu_jit = qt_config->value("use_cpu_jit", true).toBool();
+    Settings::values.use_multi_core = qt_config->value("use_multi_core", false).toBool();
    qt_config->endGroup();

    qt_config->beginGroup("System");
-    Settings::values.use_docked_mode = ReadSetting("use_docked_mode", false).toBool();
-    Settings::values.enable_nfc = ReadSetting("enable_nfc", true).toBool();
+    Settings::values.use_docked_mode = qt_config->value("use_docked_mode", false).toBool();
+    Settings::values.enable_nfc = qt_config->value("enable_nfc", true).toBool();

-    Settings::values.current_user =
-        std::clamp<int>(ReadSetting("current_user", 0).toInt(), 0, Service::Account::MAX_USERS - 1);
+    Settings::values.current_user = std::clamp<int>(qt_config->value("current_user", 0).toInt(), 0,
+                                                    Service::Account::MAX_USERS - 1);

-    Settings::values.language_index = ReadSetting("language_index", 1).toInt();
+    Settings::values.language_index = qt_config->value("language_index", 1).toInt();

-    const auto rng_seed_enabled = ReadSetting("rng_seed_enabled", false).toBool();
+    const auto rng_seed_enabled = qt_config->value("rng_seed_enabled", false).toBool();
    if (rng_seed_enabled) {
-        Settings::values.rng_seed = ReadSetting("rng_seed", 0).toULongLong();
+        Settings::values.rng_seed = qt_config->value("rng_seed", 0).toULongLong();
    } else {
        Settings::values.rng_seed = std::nullopt;
    }

-    const auto custom_rtc_enabled = ReadSetting("custom_rtc_enabled", false).toBool();
+    const auto custom_rtc_enabled = qt_config->value("custom_rtc_enabled", false).toBool();
    if (custom_rtc_enabled) {
        Settings::values.custom_rtc =
-            std::chrono::seconds(ReadSetting("custom_rtc", 0).toULongLong());
+            std::chrono::seconds(qt_config->value("custom_rtc", 0).toULongLong());
    } else {
        Settings::values.custom_rtc = std::nullopt;
    }
@@ -438,35 +439,35 @@ void Config::ReadValues() {
    qt_config->endGroup();

    qt_config->beginGroup("Miscellaneous");
-    Settings::values.log_filter = ReadSetting("log_filter", "*:Info").toString().toStdString();
-    Settings::values.use_dev_keys = ReadSetting("use_dev_keys", false).toBool();
+    Settings::values.log_filter = qt_config->value("log_filter", "*:Info").toString().toStdString();
+    Settings::values.use_dev_keys = qt_config->value("use_dev_keys", false).toBool();
    qt_config->endGroup();

    qt_config->beginGroup("Debugging");
-    Settings::values.use_gdbstub = ReadSetting("use_gdbstub", false).toBool();
-    Settings::values.gdbstub_port = ReadSetting("gdbstub_port", 24689).toInt();
-    Settings::values.program_args = ReadSetting("program_args", "").toString().toStdString();
-    Settings::values.dump_exefs = ReadSetting("dump_exefs", false).toBool();
-    Settings::values.dump_nso = ReadSetting("dump_nso", false).toBool();
+    Settings::values.use_gdbstub = qt_config->value("use_gdbstub", false).toBool();
+    Settings::values.gdbstub_port = qt_config->value("gdbstub_port", 24689).toInt();
+    Settings::values.program_args = qt_config->value("program_args", "").toString().toStdString();
+    Settings::values.dump_exefs = qt_config->value("dump_exefs", false).toBool();
+    Settings::values.dump_nso = qt_config->value("dump_nso", false).toBool();
    qt_config->endGroup();

    qt_config->beginGroup("WebService");
-    Settings::values.enable_telemetry = ReadSetting("enable_telemetry", true).toBool();
+    Settings::values.enable_telemetry = qt_config->value("enable_telemetry", true).toBool();
    Settings::values.web_api_url =
-        ReadSetting("web_api_url", "https://api.yuzu-emu.org").toString().toStdString();
-    Settings::values.yuzu_username = ReadSetting("yuzu_username").toString().toStdString();
-    Settings::values.yuzu_token = ReadSetting("yuzu_token").toString().toStdString();
+        qt_config->value("web_api_url", "https://api.yuzu-emu.org").toString().toStdString();
+    Settings::values.yuzu_username = qt_config->value("yuzu_username").toString().toStdString();
+    Settings::values.yuzu_token = qt_config->value("yuzu_token").toString().toStdString();
    qt_config->endGroup();

    const auto size = qt_config->beginReadArray("DisabledAddOns");
    for (int i = 0; i < size; ++i) {
        qt_config->setArrayIndex(i);
-        const auto title_id = ReadSetting("title_id", 0).toULongLong();
+        const auto title_id = qt_config->value("title_id", 0).toULongLong();
        std::vector<std::string> out;
        const auto d_size = qt_config->beginReadArray("disabled");
        for (int j = 0; j < d_size; ++j) {
            qt_config->setArrayIndex(j);
-            out.push_back(ReadSetting("d", "").toString().toStdString());
+            out.push_back(qt_config->value("d", "").toString().toStdString());
        }
        qt_config->endArray();
        Settings::values.disabled_addons.insert_or_assign(title_id, out);
@@ -474,38 +475,41 @@ void Config::ReadValues() {
    qt_config->endArray();

    qt_config->beginGroup("UI");
-    UISettings::values.theme = ReadSetting("theme", UISettings::themes[0].second).toString();
+    UISettings::values.theme = qt_config->value("theme", UISettings::themes[0].second).toString();
    UISettings::values.enable_discord_presence =
-        ReadSetting("enable_discord_presence", true).toBool();
+        qt_config->value("enable_discord_presence", true).toBool();
    UISettings::values.screenshot_resolution_factor =
-        static_cast<u16>(ReadSetting("screenshot_resolution_factor", 0).toUInt());
-    UISettings::values.select_user_on_boot = ReadSetting("select_user_on_boot", false).toBool();
+        static_cast<u16>(qt_config->value("screenshot_resolution_factor", 0).toUInt());
+    UISettings::values.select_user_on_boot =
+        qt_config->value("select_user_on_boot", false).toBool();

    qt_config->beginGroup("UIGameList");
-    UISettings::values.show_unknown = ReadSetting("show_unknown", true).toBool();
-    UISettings::values.show_add_ons = ReadSetting("show_add_ons", true).toBool();
-    UISettings::values.icon_size = ReadSetting("icon_size", 64).toUInt();
-    UISettings::values.row_1_text_id = ReadSetting("row_1_text_id", 3).toUInt();
-    UISettings::values.row_2_text_id = ReadSetting("row_2_text_id", 2).toUInt();
+    UISettings::values.show_unknown = qt_config->value("show_unknown", true).toBool();
+    UISettings::values.show_add_ons = qt_config->value("show_add_ons", true).toBool();
+    UISettings::values.icon_size = qt_config->value("icon_size", 64).toUInt();
+    UISettings::values.row_1_text_id = qt_config->value("row_1_text_id", 3).toUInt();
+    UISettings::values.row_2_text_id = qt_config->value("row_2_text_id", 2).toUInt();
    qt_config->endGroup();

    qt_config->beginGroup("UILayout");
-    UISettings::values.geometry = ReadSetting("geometry").toByteArray();
-    UISettings::values.state = ReadSetting("state").toByteArray();
-    UISettings::values.renderwindow_geometry = ReadSetting("geometryRenderWindow").toByteArray();
-    UISettings::values.gamelist_header_state = ReadSetting("gameListHeaderState").toByteArray();
+    UISettings::values.geometry = qt_config->value("geometry").toByteArray();
+    UISettings::values.state = qt_config->value("state").toByteArray();
+    UISettings::values.renderwindow_geometry =
+        qt_config->value("geometryRenderWindow").toByteArray();
+    UISettings::values.gamelist_header_state =
+        qt_config->value("gameListHeaderState").toByteArray();
    UISettings::values.microprofile_geometry =
-        ReadSetting("microProfileDialogGeometry").toByteArray();
+        qt_config->value("microProfileDialogGeometry").toByteArray();
    UISettings::values.microprofile_visible =
-        ReadSetting("microProfileDialogVisible", false).toBool();
+        qt_config->value("microProfileDialogVisible", false).toBool();
    qt_config->endGroup();

    qt_config->beginGroup("Paths");
-    UISettings::values.roms_path = ReadSetting("romsPath").toString();
-    UISettings::values.symbols_path = ReadSetting("symbolsPath").toString();
-    UISettings::values.gamedir = ReadSetting("gameListRootDir", ".").toString();
-    UISettings::values.gamedir_deepscan = ReadSetting("gameListDeepScan", false).toBool();
-    UISettings::values.recent_files = ReadSetting("recentFiles").toStringList();
+    UISettings::values.roms_path = qt_config->value("romsPath").toString();
+    UISettings::values.symbols_path = qt_config->value("symbolsPath").toString();
+    UISettings::values.gamedir = qt_config->value("gameListRootDir", ".").toString();
+    UISettings::values.gamedir_deepscan = qt_config->value("gameListDeepScan", false).toBool();
+    UISettings::values.recent_files = qt_config->value("recentFiles").toStringList();
    qt_config->endGroup();

    qt_config->beginGroup("Shortcuts");
@@ -518,8 +522,8 @@ void Config::ReadValues() {
            qt_config->beginGroup(hotkey);
            UISettings::values.shortcuts.emplace_back(UISettings::Shortcut(
                group + "/" + hotkey,
-                UISettings::ContextualShortcut(ReadSetting("KeySeq").toString(),
-                                               ReadSetting("Context").toInt())));
+                UISettings::ContextualShortcut(qt_config->value("KeySeq").toString(),
+                                               qt_config->value("Context").toInt())));
            qt_config->endGroup();
        }

@@ -527,16 +531,16 @@ void Config::ReadValues() {
    }
    qt_config->endGroup();

-    UISettings::values.single_window_mode = ReadSetting("singleWindowMode", true).toBool();
-    UISettings::values.fullscreen = ReadSetting("fullscreen", false).toBool();
-    UISettings::values.display_titlebar = ReadSetting("displayTitleBars", true).toBool();
-    UISettings::values.show_filter_bar = ReadSetting("showFilterBar", true).toBool();
-    UISettings::values.show_status_bar = ReadSetting("showStatusBar", true).toBool();
-    UISettings::values.confirm_before_closing = ReadSetting("confirmClose", true).toBool();
-    UISettings::values.first_start = ReadSetting("firstStart", true).toBool();
-    UISettings::values.callout_flags = ReadSetting("calloutFlags", 0).toUInt();
-    UISettings::values.show_console = ReadSetting("showConsole", false).toBool();
-    UISettings::values.profile_index = ReadSetting("profileIndex", 0).toUInt();
+    UISettings::values.single_window_mode = qt_config->value("singleWindowMode", true).toBool();
+    UISettings::values.fullscreen = qt_config->value("fullscreen", false).toBool();
+    UISettings::values.display_titlebar = qt_config->value("displayTitleBars", true).toBool();
+    UISettings::values.show_filter_bar = qt_config->value("showFilterBar", true).toBool();
+    UISettings::values.show_status_bar = qt_config->value("showStatusBar", true).toBool();
+    UISettings::values.confirm_before_closing = qt_config->value("confirmClose", true).toBool();
+    UISettings::values.first_start = qt_config->value("firstStart", true).toBool();
+    UISettings::values.callout_flags = qt_config->value("calloutFlags", 0).toUInt();
+    UISettings::values.show_console = qt_config->value("showConsole", false).toBool();
+    UISettings::values.profile_index = qt_config->value("profileIndex", 0).toUInt();

    ApplyDefaultProfileIfInputInvalid();

@@ -547,79 +551,62 @@ void Config::SavePlayerValues() {
    for (std::size_t p = 0; p < Settings::values.players.size(); ++p) {
        const auto& player = Settings::values.players[p];

-        WriteSetting(QString("player_%1_connected").arg(p), player.connected, false);
-        WriteSetting(QString("player_%1_type").arg(p), static_cast<u8>(player.type),
-                     static_cast<u8>(Settings::ControllerType::DualJoycon));
+        qt_config->setValue(QString("player_%1_connected").arg(p), player.connected);
+        qt_config->setValue(QString("player_%1_type").arg(p), static_cast<u8>(player.type));

-        WriteSetting(QString("player_%1_body_color_left").arg(p), player.body_color_left,
-                     Settings::JOYCON_BODY_NEON_BLUE);
-        WriteSetting(QString("player_%1_body_color_right").arg(p), player.body_color_right,
-                     Settings::JOYCON_BODY_NEON_RED);
-        WriteSetting(QString("player_%1_button_color_left").arg(p), player.button_color_left,
-                     Settings::JOYCON_BUTTONS_NEON_BLUE);
-        WriteSetting(QString("player_%1_button_color_right").arg(p), player.button_color_right,
-                     Settings::JOYCON_BUTTONS_NEON_RED);
+        qt_config->setValue(QString("player_%1_body_color_left").arg(p), player.body_color_left);
+        qt_config->setValue(QString("player_%1_body_color_right").arg(p), player.body_color_right);
+        qt_config->setValue(QString("player_%1_button_color_left").arg(p),
+                            player.button_color_left);
+        qt_config->setValue(QString("player_%1_button_color_right").arg(p),
+                            player.button_color_right);

        for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
-            std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
-            WriteSetting(QString("player_%1_").arg(p) +
-                             QString::fromStdString(Settings::NativeButton::mapping[i]),
-                         QString::fromStdString(player.buttons[i]),
-                         QString::fromStdString(default_param));
+            qt_config->setValue(QString("player_%1_").arg(p) +
+                                    QString::fromStdString(Settings::NativeButton::mapping[i]),
+                                QString::fromStdString(player.buttons[i]));
        }
        for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
-            std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
-                default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
-                default_analogs[i][3], default_analogs[i][4], 0.5f);
-            WriteSetting(QString("player_%1_").arg(p) +
-                             QString::fromStdString(Settings::NativeAnalog::mapping[i]),
-                         QString::fromStdString(player.analogs[i]),
-                         QString::fromStdString(default_param));
+            qt_config->setValue(QString("player_%1_").arg(p) +
+                                    QString::fromStdString(Settings::NativeAnalog::mapping[i]),
+                                QString::fromStdString(player.analogs[i]));
        }
    }
 }

 void Config::SaveDebugValues() {
-    WriteSetting("debug_pad_enabled", Settings::values.debug_pad_enabled, false);
+    qt_config->setValue("debug_pad_enabled", Settings::values.debug_pad_enabled);
    for (int i = 0; i < Settings::NativeButton::NumButtons; ++i) {
-        std::string default_param = InputCommon::GenerateKeyboardParam(default_buttons[i]);
-        WriteSetting(QString("debug_pad_") +
-                         QString::fromStdString(Settings::NativeButton::mapping[i]),
-                     QString::fromStdString(Settings::values.debug_pad_buttons[i]),
-                     QString::fromStdString(default_param));
+        qt_config->setValue(QString("debug_pad_") +
+                                QString::fromStdString(Settings::NativeButton::mapping[i]),
+                            QString::fromStdString(Settings::values.debug_pad_buttons[i]));
    }
    for (int i = 0; i < Settings::NativeAnalog::NumAnalogs; ++i) {
-        std::string default_param = InputCommon::GenerateAnalogParamFromKeys(
-            default_analogs[i][0], default_analogs[i][1], default_analogs[i][2],
-            default_analogs[i][3], default_analogs[i][4], 0.5f);
-        WriteSetting(QString("debug_pad_") +
-                         QString::fromStdString(Settings::NativeAnalog::mapping[i]),
-                     QString::fromStdString(Settings::values.debug_pad_analogs[i]),
-                     QString::fromStdString(default_param));
+        qt_config->setValue(QString("debug_pad_") +
+                                QString::fromStdString(Settings::NativeAnalog::mapping[i]),
+                            QString::fromStdString(Settings::values.debug_pad_analogs[i]));
    }
 }

 void Config::SaveMouseValues() {
-    WriteSetting("mouse_enabled", Settings::values.mouse_enabled, false);
+    qt_config->setValue("mouse_enabled", Settings::values.mouse_enabled);

    for (int i = 0; i < Settings::NativeMouseButton::NumMouseButtons; ++i) {
-        std::string default_param = InputCommon::GenerateKeyboardParam(default_mouse_buttons[i]);
-        WriteSetting(QString("mouse_") +
-                         QString::fromStdString(Settings::NativeMouseButton::mapping[i]),
-                     QString::fromStdString(Settings::values.mouse_buttons[i]),
-                     QString::fromStdString(default_param));
+        qt_config->setValue(QString("mouse_") +
+                                QString::fromStdString(Settings::NativeMouseButton::mapping[i]),
+                            QString::fromStdString(Settings::values.mouse_buttons[i]));
    }
 }

 void Config::SaveTouchscreenValues() {
-    WriteSetting("touchscreen_enabled", Settings::values.touchscreen.enabled, true);
-    WriteSetting("touchscreen_device", QString::fromStdString(Settings::values.touchscreen.device),
-                 "engine:emu_window");
+    qt_config->setValue("touchscreen_enabled", Settings::values.touchscreen.enabled);
+    qt_config->setValue("touchscreen_device",
+                        QString::fromStdString(Settings::values.touchscreen.device));

-    WriteSetting("touchscreen_finger", Settings::values.touchscreen.finger, 0);
-    WriteSetting("touchscreen_angle", Settings::values.touchscreen.rotation_angle, 0);
-    WriteSetting("touchscreen_diameter_x", Settings::values.touchscreen.diameter_x, 15);
-    WriteSetting("touchscreen_diameter_y", Settings::values.touchscreen.diameter_y, 15);
+    qt_config->setValue("touchscreen_finger", Settings::values.touchscreen.finger);
+    qt_config->setValue("touchscreen_angle", Settings::values.touchscreen.rotation_angle);
+    qt_config->setValue("touchscreen_diameter_x", Settings::values.touchscreen.diameter_x);
+    qt_config->setValue("touchscreen_diameter_y", Settings::values.touchscreen.diameter_y);
 }

 void Config::SaveValues() {
@@ -630,96 +617,89 @@ void Config::SaveValues() {
    SaveMouseValues();
    SaveTouchscreenValues();

-    WriteSetting("motion_device", QString::fromStdString(Settings::values.motion_device),
-                 "engine:motion_emu,update_period:100,sensitivity:0.01");
-    WriteSetting("keyboard_enabled", Settings::values.keyboard_enabled, false);
+    qt_config->setValue("motion_device", QString::fromStdString(Settings::values.motion_device));
+    qt_config->setValue("keyboard_enabled", Settings::values.keyboard_enabled);

    qt_config->endGroup();

    qt_config->beginGroup("Core");
-    WriteSetting("use_cpu_jit", Settings::values.use_cpu_jit, true);
-    WriteSetting("use_multi_core", Settings::values.use_multi_core, false);
+    qt_config->setValue("use_cpu_jit", Settings::values.use_cpu_jit);
+    qt_config->setValue("use_multi_core", Settings::values.use_multi_core);
    qt_config->endGroup();

    qt_config->beginGroup("Renderer");
-    WriteSetting("resolution_factor", (double)Settings::values.resolution_factor, 1.0);
-    WriteSetting("use_frame_limit", Settings::values.use_frame_limit, true);
-    WriteSetting("frame_limit", Settings::values.frame_limit, 100);
-    WriteSetting("use_disk_shader_cache", Settings::values.use_disk_shader_cache, true);
-    WriteSetting("use_accurate_gpu_emulation", Settings::values.use_accurate_gpu_emulation, false);
-    WriteSetting("use_asynchronous_gpu_emulation", Settings::values.use_asynchronous_gpu_emulation,
-                 false);
+    qt_config->setValue("resolution_factor", (double)Settings::values.resolution_factor);
+    qt_config->setValue("use_frame_limit", Settings::values.use_frame_limit);
+    qt_config->setValue("frame_limit", Settings::values.frame_limit);
+    qt_config->setValue("use_disk_shader_cache", Settings::values.use_disk_shader_cache);
+    qt_config->setValue("use_accurate_gpu_emulation", Settings::values.use_accurate_gpu_emulation);

    // Cast to double because Qt's written float values are not human-readable
-    WriteSetting("bg_red", (double)Settings::values.bg_red, 0.0);
-    WriteSetting("bg_green", (double)Settings::values.bg_green, 0.0);
-    WriteSetting("bg_blue", (double)Settings::values.bg_blue, 0.0);
+    qt_config->setValue("bg_red", (double)Settings::values.bg_red);
+    qt_config->setValue("bg_green", (double)Settings::values.bg_green);
+    qt_config->setValue("bg_blue", (double)Settings::values.bg_blue);
    qt_config->endGroup();

    qt_config->beginGroup("Audio");
-    WriteSetting("output_engine", QString::fromStdString(Settings::values.sink_id), "auto");
-    WriteSetting("enable_audio_stretching", Settings::values.enable_audio_stretching, true);
-    WriteSetting("output_device", QString::fromStdString(Settings::values.audio_device_id), "auto");
-    WriteSetting("volume", Settings::values.volume, 1.0f);
+    qt_config->setValue("output_engine", QString::fromStdString(Settings::values.sink_id));
+    qt_config->setValue("enable_audio_stretching", Settings::values.enable_audio_stretching);
+    qt_config->setValue("output_device", QString::fromStdString(Settings::values.audio_device_id));
+    qt_config->setValue("volume", Settings::values.volume);
    qt_config->endGroup();

    qt_config->beginGroup("Data Storage");
-    WriteSetting("use_virtual_sd", Settings::values.use_virtual_sd, true);
-    WriteSetting("nand_directory",
-                 QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)),
-                 QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)));
-    WriteSetting("sdmc_directory",
-                 QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir)),
-                 QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir)));
+    qt_config->setValue("use_virtual_sd", Settings::values.use_virtual_sd);
+    qt_config->setValue("nand_directory",
+                        QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir)));
+    qt_config->setValue("sdmc_directory",
+                        QString::fromStdString(FileUtil::GetUserPath(FileUtil::UserPath::SDMCDir)));
    qt_config->endGroup();

    qt_config->beginGroup("System");
-    WriteSetting("use_docked_mode", Settings::values.use_docked_mode, false);
-    WriteSetting("enable_nfc", Settings::values.enable_nfc, true);
-    WriteSetting("current_user", Settings::values.current_user, 0);
-    WriteSetting("language_index", Settings::values.language_index, 1);
+    qt_config->setValue("use_docked_mode", Settings::values.use_docked_mode);
+    qt_config->setValue("enable_nfc", Settings::values.enable_nfc);
+    qt_config->setValue("current_user", Settings::values.current_user);
+    qt_config->setValue("language_index", Settings::values.language_index);

-    WriteSetting("rng_seed_enabled", Settings::values.rng_seed.has_value(), false);
-    WriteSetting("rng_seed", Settings::values.rng_seed.value_or(0), 0);
+    qt_config->setValue("rng_seed_enabled", Settings::values.rng_seed.has_value());
+    qt_config->setValue("rng_seed", Settings::values.rng_seed.value_or(0));

-    WriteSetting("custom_rtc_enabled", Settings::values.custom_rtc.has_value(), false);
-    WriteSetting("custom_rtc",
-                 QVariant::fromValue<long long>(
-                     Settings::values.custom_rtc.value_or(std::chrono::seconds{}).count()),
-                 0);
+    qt_config->setValue("custom_rtc_enabled", Settings::values.custom_rtc.has_value());
+    qt_config->setValue("custom_rtc",
+                        QVariant::fromValue<long long>(
+                            Settings::values.custom_rtc.value_or(std::chrono::seconds{}).count()));

    qt_config->endGroup();

    qt_config->beginGroup("Miscellaneous");
-    WriteSetting("log_filter", QString::fromStdString(Settings::values.log_filter), "*:Info");
-    WriteSetting("use_dev_keys", Settings::values.use_dev_keys, false);
+    qt_config->setValue("log_filter", QString::fromStdString(Settings::values.log_filter));
+    qt_config->setValue("use_dev_keys", Settings::values.use_dev_keys);
    qt_config->endGroup();

    qt_config->beginGroup("Debugging");
-    WriteSetting("use_gdbstub", Settings::values.use_gdbstub, false);
-    WriteSetting("gdbstub_port", Settings::values.gdbstub_port, 24689);
-    WriteSetting("program_args", QString::fromStdString(Settings::values.program_args), "");
-    WriteSetting("dump_exefs", Settings::values.dump_exefs, false);
-    WriteSetting("dump_nso", Settings::values.dump_nso, false);
+    qt_config->setValue("use_gdbstub", Settings::values.use_gdbstub);
+    qt_config->setValue("gdbstub_port", Settings::values.gdbstub_port);
+    qt_config->setValue("program_args", QString::fromStdString(Settings::values.program_args));
+    qt_config->setValue("dump_exefs", Settings::values.dump_exefs);
+    qt_config->setValue("dump_nso", Settings::values.dump_nso);
    qt_config->endGroup();

    qt_config->beginGroup("WebService");
-    WriteSetting("enable_telemetry", Settings::values.enable_telemetry, true);
-    WriteSetting("web_api_url", QString::fromStdString(Settings::values.web_api_url),
-                 "https://api.yuzu-emu.org");
-    WriteSetting("yuzu_username", QString::fromStdString(Settings::values.yuzu_username));
-    WriteSetting("yuzu_token", QString::fromStdString(Settings::values.yuzu_token));
+    qt_config->setValue("enable_telemetry", Settings::values.enable_telemetry);
+    qt_config->setValue("web_api_url", QString::fromStdString(Settings::values.web_api_url));
+    qt_config->setValue("yuzu_username", QString::fromStdString(Settings::values.yuzu_username));
+    qt_config->setValue("yuzu_token", QString::fromStdString(Settings::values.yuzu_token));
    qt_config->endGroup();

    qt_config->beginWriteArray("DisabledAddOns");
    int i = 0;
    for (const auto& elem : Settings::values.disabled_addons) {
        qt_config->setArrayIndex(i);
-        WriteSetting("title_id", QVariant::fromValue<u64>(elem.first), 0);
+        qt_config->setValue("title_id", QVariant::fromValue<u64>(elem.first));
        qt_config->beginWriteArray("disabled");
        for (std::size_t j = 0; j < elem.second.size(); ++j) {
            qt_config->setArrayIndex(static_cast<int>(j));
-            WriteSetting("d", QString::fromStdString(elem.second[j]), "");
+            qt_config->setValue("d", QString::fromStdString(elem.second[j]));
        }
        qt_config->endArray();
        ++i;
@@ -727,86 +707,60 @@ void Config::SaveValues() {
    qt_config->endArray();

    qt_config->beginGroup("UI");
-    WriteSetting("theme", UISettings::values.theme, UISettings::themes[0].second);
-    WriteSetting("enable_discord_presence", UISettings::values.enable_discord_presence, true);
-    WriteSetting("screenshot_resolution_factor", UISettings::values.screenshot_resolution_factor,
-                 0);
-    WriteSetting("select_user_on_boot", UISettings::values.select_user_on_boot, false);
+    qt_config->setValue("theme", UISettings::values.theme);
+    qt_config->setValue("enable_discord_presence", UISettings::values.enable_discord_presence);
+    qt_config->setValue("screenshot_resolution_factor",
+                        UISettings::values.screenshot_resolution_factor);
+    qt_config->setValue("select_user_on_boot", UISettings::values.select_user_on_boot);

    qt_config->beginGroup("UIGameList");
-    WriteSetting("show_unknown", UISettings::values.show_unknown, true);
-    WriteSetting("show_add_ons", UISettings::values.show_add_ons, true);
-    WriteSetting("icon_size", UISettings::values.icon_size, 64);
-    WriteSetting("row_1_text_id", UISettings::values.row_1_text_id, 3);
-    WriteSetting("row_2_text_id", UISettings::values.row_2_text_id, 2);
+    qt_config->setValue("show_unknown", UISettings::values.show_unknown);
+    qt_config->setValue("show_add_ons", UISettings::values.show_add_ons);
+    qt_config->setValue("icon_size", UISettings::values.icon_size);
+    qt_config->setValue("row_1_text_id", UISettings::values.row_1_text_id);
+    qt_config->setValue("row_2_text_id", UISettings::values.row_2_text_id);
    qt_config->endGroup();

    qt_config->beginGroup("UILayout");
-    WriteSetting("geometry", UISettings::values.geometry);
-    WriteSetting("state", UISettings::values.state);
-    WriteSetting("geometryRenderWindow", UISettings::values.renderwindow_geometry);
-    WriteSetting("gameListHeaderState", UISettings::values.gamelist_header_state);
-    WriteSetting("microProfileDialogGeometry", UISettings::values.microprofile_geometry);
-    WriteSetting("microProfileDialogVisible", UISettings::values.microprofile_visible, false);
+    qt_config->setValue("geometry", UISettings::values.geometry);
+    qt_config->setValue("state", UISettings::values.state);
+    qt_config->setValue("geometryRenderWindow", UISettings::values.renderwindow_geometry);
+    qt_config->setValue("gameListHeaderState", UISettings::values.gamelist_header_state);
+    qt_config->setValue("microProfileDialogGeometry", UISettings::values.microprofile_geometry);
+    qt_config->setValue("microProfileDialogVisible", UISettings::values.microprofile_visible);
    qt_config->endGroup();

    qt_config->beginGroup("Paths");
-    WriteSetting("romsPath", UISettings::values.roms_path);
-    WriteSetting("symbolsPath", UISettings::values.symbols_path);
-    WriteSetting("screenshotPath", UISettings::values.screenshot_path);
-    WriteSetting("gameListRootDir", UISettings::values.gamedir, ".");
-    WriteSetting("gameListDeepScan", UISettings::values.gamedir_deepscan, false);
-    WriteSetting("recentFiles", UISettings::values.recent_files);
+    qt_config->setValue("romsPath", UISettings::values.roms_path);
+    qt_config->setValue("symbolsPath", UISettings::values.symbols_path);
+    qt_config->setValue("screenshotPath", UISettings::values.screenshot_path);
+    qt_config->setValue("gameListRootDir", UISettings::values.gamedir);
+    qt_config->setValue("gameListDeepScan", UISettings::values.gamedir_deepscan);
+    qt_config->setValue("recentFiles", UISettings::values.recent_files);
    qt_config->endGroup();

    qt_config->beginGroup("Shortcuts");
    for (auto shortcut : UISettings::values.shortcuts) {
-        WriteSetting(shortcut.first + "/KeySeq", shortcut.second.first);
-        WriteSetting(shortcut.first + "/Context", shortcut.second.second);
+        qt_config->setValue(shortcut.first + "/KeySeq", shortcut.second.first);
+        qt_config->setValue(shortcut.first + "/Context", shortcut.second.second);
    }
    qt_config->endGroup();

-    WriteSetting("singleWindowMode", UISettings::values.single_window_mode, true);
-    WriteSetting("fullscreen", UISettings::values.fullscreen, false);
-    WriteSetting("displayTitleBars", UISettings::values.display_titlebar, true);
-    WriteSetting("showFilterBar", UISettings::values.show_filter_bar, true);
-    WriteSetting("showStatusBar", UISettings::values.show_status_bar, true);
-    WriteSetting("confirmClose", UISettings::values.confirm_before_closing, true);
-    WriteSetting("firstStart", UISettings::values.first_start, true);
-    WriteSetting("calloutFlags", UISettings::values.callout_flags, 0);
-    WriteSetting("showConsole", UISettings::values.show_console, false);
-    WriteSetting("profileIndex", UISettings::values.profile_index, 0);
+    qt_config->setValue("singleWindowMode", UISettings::values.single_window_mode);
+    qt_config->setValue("fullscreen", UISettings::values.fullscreen);
+    qt_config->setValue("displayTitleBars", UISettings::values.display_titlebar);
+    qt_config->setValue("showFilterBar", UISettings::values.show_filter_bar);
+    qt_config->setValue("showStatusBar", UISettings::values.show_status_bar);
+    qt_config->setValue("confirmClose", UISettings::values.confirm_before_closing);
+    qt_config->setValue("firstStart", UISettings::values.first_start);
+    qt_config->setValue("calloutFlags", UISettings::values.callout_flags);
+    qt_config->setValue("showConsole", UISettings::values.show_console);
+    qt_config->setValue("profileIndex", UISettings::values.profile_index);
    qt_config->endGroup();
 }

-QVariant Config::ReadSetting(const QString& name) const {
-    return qt_config->value(name);
-}
-
-QVariant Config::ReadSetting(const QString& name, const QVariant& default_value) const {
-    QVariant result;
-    if (qt_config->value(name + "/default", false).toBool()) {
-        result = default_value;
-    } else {
-        result = qt_config->value(name, default_value);
-    }
-    return result;
-}
-
-void Config::WriteSetting(const QString& name, const QVariant& value) {
-    qt_config->setValue(name, value);
-}
-
-void Config::WriteSetting(const QString& name, const QVariant& value,
-                          const QVariant& default_value) {
-    qt_config->setValue(name + "/default", value == default_value);
-    qt_config->setValue(name, value);
-}
-
 void Config::Reload() {
    ReadValues();
-    // To apply default value changes
-    SaveValues();
    Settings::Apply();
 }

@@ -42,11 +42,6 @@ private:
    void SaveMouseValues();
    void SaveTouchscreenValues();

-    QVariant ReadSetting(const QString& name) const;
-    QVariant ReadSetting(const QString& name, const QVariant& default_value) const;
-    void WriteSetting(const QString& name, const QVariant& value);
-    void WriteSetting(const QString& name, const QVariant& value, const QVariant& default_value);
-
    std::unique_ptr<QSettings> qt_config;
    std::string qt_config_loc;
 };
@@ -75,8 +75,6 @@ void ConfigureGraphics::setConfiguration() {
    ui->frame_limit->setValue(Settings::values.frame_limit);
    ui->use_disk_shader_cache->setChecked(Settings::values.use_disk_shader_cache);
    ui->use_accurate_gpu_emulation->setChecked(Settings::values.use_accurate_gpu_emulation);
-    ui->use_asynchronous_gpu_emulation->setEnabled(!Core::System::GetInstance().IsPoweredOn());
-    ui->use_asynchronous_gpu_emulation->setChecked(Settings::values.use_asynchronous_gpu_emulation);
    UpdateBackgroundColorButton(QColor::fromRgbF(Settings::values.bg_red, Settings::values.bg_green,
                                                 Settings::values.bg_blue));
 }
@@ -88,8 +86,6 @@ void ConfigureGraphics::applyConfiguration() {
    Settings::values.frame_limit = ui->frame_limit->value();
    Settings::values.use_disk_shader_cache = ui->use_disk_shader_cache->isChecked();
    Settings::values.use_accurate_gpu_emulation = ui->use_accurate_gpu_emulation->isChecked();
-    Settings::values.use_asynchronous_gpu_emulation =
-        ui->use_asynchronous_gpu_emulation->isChecked();
    Settings::values.bg_red = static_cast<float>(bg_color.redF());
    Settings::values.bg_green = static_cast<float>(bg_color.greenF());
    Settings::values.bg_blue = static_cast<float>(bg_color.blueF());
@@ -63,13 +63,6 @@
          </property>
         </widget>
        </item>
-        <item>
-         <widget class="QCheckBox" name="use_asynchronous_gpu_emulation">
-          <property name="text">
-           <string>Use asynchronous GPU emulation</string>
-          </property>
-         </widget>
-        </item>
        <item>
         <layout class="QHBoxLayout" name="horizontalLayout">
          <item>
@@ -81,8 +81,9 @@ QString WaitTreeText::GetText() const {
    return text;
 }

-WaitTreeMutexInfo::WaitTreeMutexInfo(VAddr mutex_address, const Kernel::HandleTable& handle_table)
-    : mutex_address(mutex_address) {
+WaitTreeMutexInfo::WaitTreeMutexInfo(VAddr mutex_address) : mutex_address(mutex_address) {
+    const auto& handle_table = Core::CurrentProcess()->GetHandleTable();
+
    mutex_value = Memory::Read32(mutex_address);
    owner_handle = static_cast<Kernel::Handle>(mutex_value & Kernel::Mutex::MutexOwnerMask);
    owner = handle_table.Get<Kernel::Thread>(owner_handle);
@@ -315,8 +316,7 @@ std::vector<std::unique_ptr<WaitTreeItem>> WaitTreeThread::GetChildren() const {

    const VAddr mutex_wait_address = thread.GetMutexWaitAddress();
    if (mutex_wait_address != 0) {
-        const auto& handle_table = thread.GetOwnerProcess()->GetHandleTable();
-        list.push_back(std::make_unique<WaitTreeMutexInfo>(mutex_wait_address, handle_table));
+        list.push_back(std::make_unique<WaitTreeMutexInfo>(mutex_wait_address));
    } else {
        list.push_back(std::make_unique<WaitTreeText>(tr("not waiting for mutex")));
    }
@@ -17,7 +17,6 @@
 class EmuThread;

 namespace Kernel {
-class HandleTable;
 class ReadableEvent;
 class WaitObject;
 class Thread;
@@ -73,7 +72,7 @@ public:
 class WaitTreeMutexInfo : public WaitTreeExpandableItem {
    Q_OBJECT
 public:
-    explicit WaitTreeMutexInfo(VAddr mutex_address, const Kernel::HandleTable& handle_table);
+    explicit WaitTreeMutexInfo(VAddr mutex_address);
    ~WaitTreeMutexInfo() override;

    QString GetText() const override;
@@ -849,7 +849,7 @@ bool GMainWindow::LoadROM(const QString& filename) {
    }
    game_path = filename;

-    system.TelemetrySession().AddField(Telemetry::FieldType::App, "Frontend", "Qt");
+    Core::Telemetry().AddField(Telemetry::FieldType::App, "Frontend", "Qt");
    return true;
 }

@@ -354,8 +354,6 @@ void Config::ReadValues() {
        sdl2_config->GetBoolean("Renderer", "use_disk_shader_cache", false);
    Settings::values.use_accurate_gpu_emulation =
        sdl2_config->GetBoolean("Renderer", "use_accurate_gpu_emulation", false);
-    Settings::values.use_asynchronous_gpu_emulation =
-        sdl2_config->GetBoolean("Renderer", "use_asynchronous_gpu_emulation", false);

    Settings::values.bg_red = (float)sdl2_config->GetReal("Renderer", "bg_red", 0.0);
    Settings::values.bg_green = (float)sdl2_config->GetReal("Renderer", "bg_green", 0.0);
@@ -118,10 +118,6 @@ use_disk_shader_cache =
 # 0 (default): Off (fast), 1 : On (slow)
 use_accurate_gpu_emulation =

-# Whether to use asynchronous GPU emulation
-# 0 : Off (slow), 1 (default): On (fast)
-use_asynchronous_gpu_emulation =
-
 # The clear color for the renderer. What shows up on the sides of the bottom screen.
 # Must be in range of 0.0-1.0. Defaults to 1.0 for all.
 bg_red =
@@ -216,7 +216,7 @@ int main(int argc, char** argv) {
        }
    }

-    system.TelemetrySession().AddField(Telemetry::FieldType::App, "Frontend", "SDL");
+    Core::Telemetry().AddField(Telemetry::FieldType::App, "Frontend", "SDL");

    system.Renderer().Rasterizer().LoadDiskResources();