Add frametime logging for tracking performance over time

Co-Authored-By: jroweboy <[email protected]>
2019-08-26 17:29:08 +02:00
172 changed files with 1979 additions and 4379 deletions
@@ -10,7 +10,7 @@ jobs:
        BuildSuffix: 'windows-testing'
        ScriptFolder: 'windows'
  steps:
-  - script: sudo apt-get update && sudo apt-get --only-upgrade -y install python3-pip && pip install requests urllib3
+  - script: sudo apt upgrade python3-pip && pip install requests urllib3
    displayName: 'Prepare Environment'
  - task: PythonScript@0
    condition: eq(variables['Build.Reason'], 'PullRequest')
@@ -81,7 +81,6 @@ set(HASH_FILES
    "${VIDEO_CORE}/shader/decode/register_set_predicate.cpp"
    "${VIDEO_CORE}/shader/decode/shift.cpp"
    "${VIDEO_CORE}/shader/decode/video.cpp"
-    "${VIDEO_CORE}/shader/decode/warp.cpp"
    "${VIDEO_CORE}/shader/decode/xmad.cpp"
    "${VIDEO_CORE}/shader/control_flow.cpp"
    "${VIDEO_CORE}/shader/control_flow.h"
@@ -1,31 +0,0 @@
-The icons in this folder and its subfolders have the following licenses:
-
-Icon Name | License | Origin/Author
--- | --- | ---
-qt_themes/default/icons/16x16/checked.png | Free for non-commercial use
-qt_themes/default/icons/16x16/failed.png | Free for non-commercial use
-qt_themes/default/icons/16x16/lock.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/default/icons/256x256/plus_folder.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/default/icons/48x48/bad_folder.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/default/icons/48x48/chip.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/default/icons/48x48/folder.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/default/icons/48x48/plus.png | CC0 1.0 | Designed by BreadFish64 from the Citra team
-qt_themes/default/icons/48x48/sd_card.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/qdarkstyle/icons/16x16/checked.png | Free for non-commercial use
-qt_themes/qdarkstyle/icons/16x16/failed.png | Free for non-commercial use
-qt_themes/qdarkstyle/icons/16x16/lock.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/qdarkstyle/icons/256x256/plus_folder.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/qdarkstyle/icons/48x48/bad_folder.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/qdarkstyle/icons/48x48/chip.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/qdarkstyle/icons/48x48/folder.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/qdarkstyle/icons/48x48/plus.png | CC0 1.0 | Designed by BreadFish64 from the Citra team
-qt_themes/qdarkstyle/icons/48x48/sd_card.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/colorful/icons/16x16/lock.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/colorful/icons/256x256/plus_folder.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/colorful/icons/48x48/bad_folder.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/colorful/icons/48x48/chip.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/colorful/icons/48x48/folder.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/colorful/icons/48x48/plus.png | CC BY-ND 3.0 | https://icons8.com
-qt_themes/colorful/icons/48x48/sd_card.png | CC BY-ND 3.0 | https://icons8.com
-
-<!-- TODO: Add the license of the yuzu icon -->
@@ -1,14 +0,0 @@
-[Icon Theme]
-Name=colorful
-Comment=Colorful theme
-Inherits=default
-Directories=16x16,48x48,256x256
- 
-[16x16]
-Size=16
-
-[48x48]
-Size=48
-
-[256x256]
-Size=256
@@ -1,15 +0,0 @@
-<RCC>
-    <qresource prefix="icons/colorful">
-        <file alias="index.theme">icons/index.theme</file>
-        <file alias="16x16/lock.png">icons/16x16/lock.png</file>
-        <file alias="48x48/bad_folder.png">icons/48x48/bad_folder.png</file>
-        <file alias="48x48/chip.png">icons/48x48/chip.png</file>
-        <file alias="48x48/folder.png">icons/48x48/folder.png</file>
-        <file alias="48x48/plus.png">icons/48x48/plus.png</file>
-        <file alias="48x48/sd_card.png">icons/48x48/sd_card.png</file>
-        <file alias="256x256/plus_folder.png">icons/256x256/plus_folder.png</file>
-    </qresource>
-    <qresource prefix="colorful">
-        <file>style.qss</file>
-    </qresource>
-</RCC>
@@ -1,4 +0,0 @@
-/*
-    This file is intentionally left blank.
-    We do not want to apply any stylesheet for colorful, only icons.
-*/
@@ -1,8 +0,0 @@
-[Icon Theme]
-Name=colorful_dark
-Comment=Colorful theme (Dark style)
-Inherits=default
-Directories=16x16
- 
-[16x16]
-Size=16
@@ -1,57 +0,0 @@
-<RCC>
-    <qresource prefix="icons/colorful_dark">
-        <file alias="index.theme">icons/index.theme</file>
-        <file alias="16x16/lock.png">icons/16x16/lock.png</file>
-        <file alias="48x48/bad_folder.png">../colorful/icons/48x48/bad_folder.png</file>
-        <file alias="48x48/chip.png">../colorful/icons/48x48/chip.png</file>
-        <file alias="48x48/folder.png">../colorful/icons/48x48/folder.png</file>
-        <file alias="48x48/plus.png">../colorful/icons/48x48/plus.png</file>
-        <file alias="48x48/sd_card.png">../colorful/icons/48x48/sd_card.png</file>
-        <file alias="256x256/plus_folder.png">../colorful/icons/256x256/plus_folder.png</file>
-    </qresource>
-
-    <qresource prefix="qss_icons">
-        <file alias="rc/up_arrow_disabled.png">../qdarkstyle/rc/up_arrow_disabled.png</file>
-        <file alias="rc/Hmovetoolbar.png">../qdarkstyle/rc/Hmovetoolbar.png</file>
-        <file alias="rc/stylesheet-branch-end.png">../qdarkstyle/rc/stylesheet-branch-end.png</file>
-        <file alias="rc/branch_closed-on.png">../qdarkstyle/rc/branch_closed-on.png</file>
-        <file alias="rc/stylesheet-vline.png">../qdarkstyle/rc/stylesheet-vline.png</file>
-        <file alias="rc/branch_closed.png">../qdarkstyle/rc/branch_closed.png</file>
-        <file alias="rc/branch_open-on.png">../qdarkstyle/rc/branch_open-on.png</file>
-        <file alias="rc/transparent.png">../qdarkstyle/rc/transparent.png</file>
-        <file alias="rc/right_arrow_disabled.png">../qdarkstyle/rc/right_arrow_disabled.png</file>
-        <file alias="rc/sizegrip.png">../qdarkstyle/rc/sizegrip.png</file>
-        <file alias="rc/close.png">../qdarkstyle/rc/close.png</file>
-        <file alias="rc/close-hover.png">../qdarkstyle/rc/close-hover.png</file>
-        <file alias="rc/close-pressed.png">../qdarkstyle/rc/close-pressed.png</file>
-        <file alias="rc/down_arrow.png">../qdarkstyle/rc/down_arrow.png</file>
-        <file alias="rc/Vmovetoolbar.png">../qdarkstyle/rc/Vmovetoolbar.png</file>
-        <file alias="rc/left_arrow.png">../qdarkstyle/rc/left_arrow.png</file>
-        <file alias="rc/stylesheet-branch-more.png">../qdarkstyle/rc/stylesheet-branch-more.png</file>
-        <file alias="rc/up_arrow.png">../qdarkstyle/rc/up_arrow.png</file>
-        <file alias="rc/right_arrow.png">../qdarkstyle/rc/right_arrow.png</file>
-        <file alias="rc/left_arrow_disabled.png">../qdarkstyle/rc/left_arrow_disabled.png</file>
-        <file alias="rc/Hsepartoolbar.png">../qdarkstyle/rc/Hsepartoolbar.png</file>
-        <file alias="rc/branch_open.png">../qdarkstyle/rc/branch_open.png</file>
-        <file alias="rc/Vsepartoolbar.png">../qdarkstyle/rc/Vsepartoolbar.png</file>
-        <file alias="rc/down_arrow_disabled.png">../qdarkstyle/rc/down_arrow_disabled.png</file>
-        <file alias="rc/undock.png">../qdarkstyle/rc/undock.png</file>
-        <file alias="rc/checkbox_checked_disabled.png">../qdarkstyle/rc/checkbox_checked_disabled.png</file>
-        <file alias="rc/checkbox_checked_focus.png">../qdarkstyle/rc/checkbox_checked_focus.png</file>
-        <file alias="rc/checkbox_checked.png">../qdarkstyle/rc/checkbox_checked.png</file>
-        <file alias="rc/checkbox_indeterminate.png">../qdarkstyle/rc/checkbox_indeterminate.png</file>
-        <file alias="rc/checkbox_indeterminate_focus.png">../qdarkstyle/rc/checkbox_indeterminate_focus.png</file>
-        <file alias="rc/checkbox_unchecked_disabled.png">../qdarkstyle/rc/checkbox_unchecked_disabled.png</file>
-        <file alias="rc/checkbox_unchecked_focus.png">../qdarkstyle/rc/checkbox_unchecked_focus.png</file>
-        <file alias="rc/checkbox_unchecked.png">../qdarkstyle/rc/checkbox_unchecked.png</file>
-        <file alias="rc/radio_checked_disabled.png">../qdarkstyle/rc/radio_checked_disabled.png</file>
-        <file alias="rc/radio_checked_focus.png">../qdarkstyle/rc/radio_checked_focus.png</file>
-        <file alias="rc/radio_checked.png">../qdarkstyle/rc/radio_checked.png</file>
-        <file alias="rc/radio_unchecked_disabled.png">../qdarkstyle/rc/radio_unchecked_disabled.png</file>
-        <file alias="rc/radio_unchecked_focus.png">../qdarkstyle/rc/radio_unchecked_focus.png</file>
-        <file alias="rc/radio_unchecked.png">../qdarkstyle/rc/radio_unchecked.png</file>
-    </qresource>
-    <qresource prefix="colorful_dark">
-        <file alias="style.qss">../qdarkstyle/style.qss</file>
-    </qresource>
-</RCC>
@@ -5,21 +5,7 @@
        <file alias="16x16/checked.png">icons/16x16/checked.png</file>

        <file alias="16x16/failed.png">icons/16x16/failed.png</file>
-
-        <file alias="16x16/lock.png">icons/16x16/lock.png</file>
-
-        <file alias="48x48/bad_folder.png">icons/48x48/bad_folder.png</file>
-      
-        <file alias="48x48/chip.png">icons/48x48/chip.png</file>
-
-        <file alias="48x48/folder.png">icons/48x48/folder.png</file>
-
-        <file alias="48x48/plus.png">icons/48x48/plus.png</file>
-      
-        <file alias="48x48/sd_card.png">icons/48x48/sd_card.png</file>
      
        <file alias="256x256/yuzu.png">icons/256x256/yuzu.png</file>
-
-        <file alias="256x256/plus_folder.png">icons/256x256/plus_folder.png</file>
    </qresource>
 </RCC>
@@ -1,13 +1,10 @@
 [Icon Theme]
 Name=default
 Comment=default theme
-Directories=16x16,48x48,256x256
+Directories=16x16,256x256
 
 [16x16]
 Size=16
-
-[48x48]
-Size=48
 
 [256x256]
 Size=256
@@ -2,13 +2,10 @@
 Name=qdarkstyle
 Comment=dark theme
 Inherits=default
-Directories=16x16,48x48,256x256
+Directories=16x16,256x256
 
 [16x16]
 Size=16
-
-[48x48]
-Size=48
-
+ 
 [256x256]
 Size=256
@@ -1,13 +1,6 @@
 <RCC>
  <qresource prefix="icons/qdarkstyle">
    <file alias="index.theme">icons/index.theme</file>
-    <file alias="16x16/lock.png">icons/16x16/lock.png</file>
-    <file alias="48x48/bad_folder.png">icons/48x48/bad_folder.png</file>
-    <file alias="48x48/chip.png">icons/48x48/chip.png</file>
-    <file alias="48x48/folder.png">icons/48x48/folder.png</file>
-    <file alias="48x48/plus.png">icons/48x48/plus.png</file>
-    <file alias="48x48/sd_card.png">icons/48x48/sd_card.png</file>
-    <file alias="256x256/plus_folder.png">icons/256x256/plus_folder.png</file>
  </qresource>
  <qresource prefix="qss_icons">
    <file>rc/up_arrow_disabled.png</file>
@@ -337,19 +337,3 @@ proprietary programs.  If your program is a subroutine library, you may
 consider it more useful to permit linking proprietary applications with the
 library.  If this is what you want to do, use the GNU Lesser General
 Public License instead of this License.
-
-
-The icons used in this project have the following licenses:
-
-Icon Name                          | License       | Origin/Author
---                                | ---           | ---
-checked.png                        | Free for non-commercial use
-failed.png                         | Free for non-commercial use
-lock.png                           | CC BY-ND 3.0  | https://icons8.com
-plus_folder.png                    | CC BY-ND 3.0  | https://icons8.com
-bad_folder.png                     | CC BY-ND 3.0  | https://icons8.com
-chip.png                           | CC BY-ND 3.0  | https://icons8.com
-folder.png                         | CC BY-ND 3.0  | https://icons8.com
-plus.png (Default, Dark)           | CC0 1.0       | Designed by BreadFish64 from the Citra team
-plus.png (Colorful, Colorful Dark) | CC BY-ND 3.0  | https://icons8.com
-sd_card.png | CC BY-ND 3.0 | https://icons8.com
@@ -55,7 +55,6 @@ add_custom_command(OUTPUT scm_rev.cpp
      "${VIDEO_CORE}/shader/decode/register_set_predicate.cpp"
      "${VIDEO_CORE}/shader/decode/shift.cpp"
      "${VIDEO_CORE}/shader/decode/video.cpp"
-      "${VIDEO_CORE}/shader/decode/warp.cpp"
      "${VIDEO_CORE}/shader/decode/xmad.cpp"
      "${VIDEO_CORE}/shader/control_flow.cpp"
      "${VIDEO_CORE}/shader/control_flow.h"
@@ -70,8 +70,6 @@ add_library(core STATIC
    file_sys/sdmc_factory.h
    file_sys/submission_package.cpp
    file_sys/submission_package.h
-    file_sys/system_archive/mii_model.cpp
-    file_sys/system_archive/mii_model.h
    file_sys/system_archive/ng_word.cpp
    file_sys/system_archive/ng_word.h
    file_sys/system_archive/system_archive.cpp
@@ -104,8 +104,7 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
    return vfs->OpenFile(path, FileSys::Mode::Read);
 }
 struct System::Impl {
-    explicit Impl(System& system)
-        : kernel{system}, cpu_core_manager{system}, applet_manager{system}, reporter{system} {}
+    explicit Impl(System& system) : kernel{system}, cpu_core_manager{system}, reporter{system} {}

    Cpu& CurrentCpuCore() {
        return cpu_core_manager.GetCurrentCore();
@@ -160,10 +159,6 @@ struct System::Impl {

        LOG_DEBUG(Core, "Initialized OK");

-        // Reset counters and set time origin to current frame
-        GetAndResetPerfStats();
-        perf_stats.BeginSystemFrame();
-
        return ResultStatus::Success;
    }

@@ -206,6 +201,16 @@ struct System::Impl {
        main_process->Run(load_parameters->main_thread_priority,
                          load_parameters->main_thread_stack_size);

+        u64 title_id{0};
+        if (app_loader->ReadProgramId(title_id) != Loader::ResultStatus::Success) {
+            LOG_ERROR(Core, "Failed to find title id for ROM (Error {})",
+                      static_cast<u32>(load_result));
+        }
+        perf_stats = std::make_unique<PerfStats>(title_id);
+        // Reset counters and set time origin to current frame
+        GetAndResetPerfStats();
+        perf_stats->BeginSystemFrame();
+
        status = ResultStatus::Success;
        return status;
    }
@@ -219,6 +224,8 @@ struct System::Impl {
                                    perf_results.game_fps);
        telemetry_session->AddField(Telemetry::FieldType::Performance, "Shutdown_Frametime",
                                    perf_results.frametime * 1000.0);
+        telemetry_session->AddField(Telemetry::FieldType::Performance, "Mean_Frametime_MS",
+                                    perf_stats->GetMeanFrametime());

        is_powered_on = false;

@@ -229,6 +236,7 @@ struct System::Impl {
        service_manager.reset();
        cheat_engine.reset();
        telemetry_session.reset();
+        perf_stats.reset();
        gpu_core.reset();

        // Close all CPU/threading state
@@ -286,7 +294,7 @@ struct System::Impl {
    }

    PerfStatsResults GetAndResetPerfStats() {
-        return perf_stats.GetAndResetStats(core_timing.GetGlobalTimeUs());
+        return perf_stats->GetAndResetStats(core_timing.GetGlobalTimeUs());
    }

    Timing::CoreTiming core_timing;
@@ -327,7 +335,7 @@ struct System::Impl {
    ResultStatus status = ResultStatus::Success;
    std::string status_details = "";

-    Core::PerfStats perf_stats;
+    std::unique_ptr<Core::PerfStats> perf_stats;
    Core::FrameLimiter frame_limiter;
 };

@@ -480,11 +488,11 @@ const Timing::CoreTiming& System::CoreTiming() const {
 }

 Core::PerfStats& System::GetPerfStats() {
-    return impl->perf_stats;
+    return *impl->perf_stats;
 }

 const Core::PerfStats& System::GetPerfStats() const {
-    return impl->perf_stats;
+    return *impl->perf_stats;
 }

 Core::FrameLimiter& System::FrameLimiter() {
@@ -37,7 +37,6 @@
 namespace Core::Crypto {

 constexpr u64 CURRENT_CRYPTO_REVISION = 0x5;
-constexpr u64 FULL_TICKET_SIZE = 0x400;

 using namespace Common;

@@ -56,99 +55,6 @@ const std::map<std::pair<S128KeyType, u64>, std::string> KEYS_VARIABLE_LENGTH{
    {{S128KeyType::KeyblobMAC, 0}, "keyblob_mac_key_"},
 };

-namespace {
-template <std::size_t Size>
-bool IsAllZeroArray(const std::array<u8, Size>& array) {
-    return std::all_of(array.begin(), array.end(), [](const auto& elem) { return elem == 0; });
-}
-} // namespace
-
-u64 GetSignatureTypeDataSize(SignatureType type) {
-    switch (type) {
-    case SignatureType::RSA_4096_SHA1:
-    case SignatureType::RSA_4096_SHA256:
-        return 0x200;
-    case SignatureType::RSA_2048_SHA1:
-    case SignatureType::RSA_2048_SHA256:
-        return 0x100;
-    case SignatureType::ECDSA_SHA1:
-    case SignatureType::ECDSA_SHA256:
-        return 0x3C;
-    }
-    UNREACHABLE();
-}
-
-u64 GetSignatureTypePaddingSize(SignatureType type) {
-    switch (type) {
-    case SignatureType::RSA_4096_SHA1:
-    case SignatureType::RSA_4096_SHA256:
-    case SignatureType::RSA_2048_SHA1:
-    case SignatureType::RSA_2048_SHA256:
-        return 0x3C;
-    case SignatureType::ECDSA_SHA1:
-    case SignatureType::ECDSA_SHA256:
-        return 0x40;
-    }
-    UNREACHABLE();
-}
-
-SignatureType Ticket::GetSignatureType() const {
-    if (auto ticket = std::get_if<RSA4096Ticket>(&data)) {
-        return ticket->sig_type;
-    }
-    if (auto ticket = std::get_if<RSA2048Ticket>(&data)) {
-        return ticket->sig_type;
-    }
-    if (auto ticket = std::get_if<ECDSATicket>(&data)) {
-        return ticket->sig_type;
-    }
-
-    UNREACHABLE();
-}
-
-TicketData& Ticket::GetData() {
-    if (auto ticket = std::get_if<RSA4096Ticket>(&data)) {
-        return ticket->data;
-    }
-    if (auto ticket = std::get_if<RSA2048Ticket>(&data)) {
-        return ticket->data;
-    }
-    if (auto ticket = std::get_if<ECDSATicket>(&data)) {
-        return ticket->data;
-    }
-
-    UNREACHABLE();
-}
-
-const TicketData& Ticket::GetData() const {
-    if (auto ticket = std::get_if<RSA4096Ticket>(&data)) {
-        return ticket->data;
-    }
-    if (auto ticket = std::get_if<RSA2048Ticket>(&data)) {
-        return ticket->data;
-    }
-    if (auto ticket = std::get_if<ECDSATicket>(&data)) {
-        return ticket->data;
-    }
-
-    UNREACHABLE();
-}
-
-u64 Ticket::GetSize() const {
-    const auto sig_type = GetSignatureType();
-
-    return sizeof(SignatureType) + GetSignatureTypeDataSize(sig_type) +
-           GetSignatureTypePaddingSize(sig_type) + sizeof(TicketData);
-}
-
-Ticket Ticket::SynthesizeCommon(Key128 title_key, const std::array<u8, 16>& rights_id) {
-    RSA2048Ticket out{};
-    out.sig_type = SignatureType::RSA_2048_SHA256;
-    out.data.rights_id = rights_id;
-    out.data.title_key_common = title_key;
-    return Ticket{out};
-}
-
 Key128 GenerateKeyEncryptionKey(Key128 source, Key128 master, Key128 kek_seed, Key128 key_seed) {
    Key128 out{};

@@ -229,27 +135,6 @@ void KeyManager::DeriveGeneralPurposeKeys(std::size_t crypto_revision) {
    }
 }

-RSAKeyPair<2048> KeyManager::GetETicketRSAKey() const {
-    if (IsAllZeroArray(eticket_extended_kek) || !HasKey(S128KeyType::ETicketRSAKek))
-        return {};
-
-    const auto eticket_final = GetKey(S128KeyType::ETicketRSAKek);
-
-    std::vector<u8> extended_iv(eticket_extended_kek.begin(), eticket_extended_kek.begin() + 0x10);
-    std::array<u8, 0x230> extended_dec{};
-    AESCipher<Key128> rsa_1(eticket_final, Mode::CTR);
-    rsa_1.SetIV(extended_iv);
-    rsa_1.Transcode(eticket_extended_kek.data() + 0x10, eticket_extended_kek.size() - 0x10,
-                    extended_dec.data(), Op::Decrypt);
-
-    RSAKeyPair<2048> rsa_key{};
-    std::memcpy(rsa_key.decryption_key.data(), extended_dec.data(), rsa_key.decryption_key.size());
-    std::memcpy(rsa_key.modulus.data(), extended_dec.data() + 0x100, rsa_key.modulus.size());
-    std::memcpy(rsa_key.exponent.data(), extended_dec.data() + 0x200, rsa_key.exponent.size());
-
-    return rsa_key;
-}
-
 Key128 DeriveKeyblobMACKey(const Key128& keyblob_key, const Key128& mac_source) {
    AESCipher<Key128> mac_cipher(keyblob_key, Mode::ECB);
    Key128 mac_key{};
@@ -352,7 +237,7 @@ Loader::ResultStatus DeriveSDKeys(std::array<Key256, 2>& sd_keys, KeyManager& ke
    return Loader::ResultStatus::Success;
 }

-std::vector<Ticket> GetTicketblob(const FileUtil::IOFile& ticket_save) {
+std::vector<TicketRaw> GetTicketblob(const FileUtil::IOFile& ticket_save) {
    if (!ticket_save.IsOpen())
        return {};

@@ -361,14 +246,14 @@ std::vector<Ticket> GetTicketblob(const FileUtil::IOFile& ticket_save) {
        return {};
    }

-    std::vector<Ticket> out;
+    std::vector<TicketRaw> out;
    for (std::size_t offset = 0; offset + 0x4 < buffer.size(); ++offset) {
        if (buffer[offset] == 0x4 && buffer[offset + 1] == 0x0 && buffer[offset + 2] == 0x1 &&
            buffer[offset + 3] == 0x0) {
            out.emplace_back();
            auto& next = out.back();
-            std::memcpy(&next, buffer.data() + offset, sizeof(Ticket));
-            offset += FULL_TICKET_SIZE;
+            std::memcpy(&next, buffer.data() + offset, sizeof(TicketRaw));
+            offset += next.size();
        }
    }

@@ -420,23 +305,29 @@ static std::optional<u64> FindTicketOffset(const std::array<u8, size>& data) {
    return offset;
 }

-std::optional<std::pair<Key128, Key128>> ParseTicket(const Ticket& ticket,
+std::optional<std::pair<Key128, Key128>> ParseTicket(const TicketRaw& ticket,
                                                     const RSAKeyPair<2048>& key) {
-    const auto issuer = ticket.GetData().issuer;
-    if (issuer == std::array<u8, 0x40>{})
+    u32 cert_authority;
+    std::memcpy(&cert_authority, ticket.data() + 0x140, sizeof(cert_authority));
+    if (cert_authority == 0)
        return {};
-    if (issuer[0] != 'R' || issuer[1] != 'o' || issuer[2] != 'o' || issuer[3] != 't') {
-        LOG_INFO(Crypto, "Attempting to parse ticket with non-standard certificate authority.");
+    if (cert_authority != Common::MakeMagic('R', 'o', 'o', 't')) {
+        LOG_INFO(Crypto,
+                 "Attempting to parse ticket with non-standard certificate authority {:08X}.",
+                 cert_authority);
    }

-    Key128 rights_id = ticket.GetData().rights_id;
+    Key128 rights_id;
+    std::memcpy(rights_id.data(), ticket.data() + 0x2A0, sizeof(Key128));

    if (rights_id == Key128{})
        return {};

-    if (!std::any_of(ticket.GetData().title_key_common_pad.begin(),
-                     ticket.GetData().title_key_common_pad.end(), [](u8 b) { return b != 0; })) {
-        return std::make_pair(rights_id, ticket.GetData().title_key_common);
+    Key128 key_temp{};
+
+    if (!std::any_of(ticket.begin() + 0x190, ticket.begin() + 0x280, [](u8 b) { return b != 0; })) {
+        std::memcpy(key_temp.data(), ticket.data() + 0x180, key_temp.size());
+        return std::make_pair(rights_id, key_temp);
    }

    mbedtls_mpi D; // RSA Private Exponent
@@ -451,7 +342,7 @@ std::optional<std::pair<Key128, Key128>> ParseTicket(const Ticket& ticket,

    mbedtls_mpi_read_binary(&D, key.decryption_key.data(), key.decryption_key.size());
    mbedtls_mpi_read_binary(&N, key.modulus.data(), key.modulus.size());
-    mbedtls_mpi_read_binary(&S, ticket.GetData().title_key_block.data(), 0x100);
+    mbedtls_mpi_read_binary(&S, ticket.data() + 0x180, 0x100);

    mbedtls_mpi_exp_mod(&M, &S, &D, &N, nullptr);

@@ -475,7 +366,6 @@ std::optional<std::pair<Key128, Key128>> ParseTicket(const Ticket& ticket,
        return {};
    ASSERT(*offset > 0);

-    Key128 key_temp{};
    std::memcpy(key_temp.data(), m_2.data() + *offset, key_temp.size());

    return std::make_pair(rights_id, key_temp);
@@ -560,8 +450,6 @@ void KeyManager::LoadFromFile(const std::string& filename, bool is_title_keys) {

                const auto index = std::stoul(out[0].substr(18, 2), nullptr, 16);
                encrypted_keyblobs[index] = Common::HexStringToArray<0xB0>(out[1]);
-            } else if (out[0].compare(0, 20, "eticket_extended_kek") == 0) {
-                eticket_extended_kek = Common::HexStringToArray<576>(out[1]);
            } else {
                for (const auto& kv : KEYS_VARIABLE_LENGTH) {
                    if (!ValidCryptoRevisionString(out[0], kv.second.size(), 2))
@@ -974,19 +862,20 @@ void KeyManager::DeriveETicket(PartitionDataManager& data) {
    // Titlekeys
    data.DecryptProdInfo(GetBISKey(0));

-    eticket_extended_kek = data.GetETicketExtendedKek();
-    WriteKeyToFile(KeyCategory::Console, "eticket_extended_kek", eticket_extended_kek);
-    PopulateTickets();
-}
+    const auto eticket_extended_kek = data.GetETicketExtendedKek();

-void KeyManager::PopulateTickets() {
-    const auto rsa_key = GetETicketRSAKey();
+    std::vector<u8> extended_iv(0x10);
+    std::memcpy(extended_iv.data(), eticket_extended_kek.data(), extended_iv.size());
+    std::array<u8, 0x230> extended_dec{};
+    AESCipher<Key128> rsa_1(eticket_final, Mode::CTR);
+    rsa_1.SetIV(extended_iv);
+    rsa_1.Transcode(eticket_extended_kek.data() + 0x10, eticket_extended_kek.size() - 0x10,
+                    extended_dec.data(), Op::Decrypt);

-    if (rsa_key == RSAKeyPair<2048>{})
-        return;
-
-    if (!common_tickets.empty() && !personal_tickets.empty())
-        return;
+    RSAKeyPair<2048> rsa_key{};
+    std::memcpy(rsa_key.decryption_key.data(), extended_dec.data(), rsa_key.decryption_key.size());
+    std::memcpy(rsa_key.modulus.data(), extended_dec.data() + 0x100, rsa_key.modulus.size());
+    std::memcpy(rsa_key.exponent.data(), extended_dec.data() + 0x200, rsa_key.exponent.size());

    const FileUtil::IOFile save1(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
                                     "/system/save/80000000000000e1",
@@ -997,41 +886,19 @@ void KeyManager::PopulateTickets() {

    const auto blob2 = GetTicketblob(save2);
    auto res = GetTicketblob(save1);
-    const auto idx = res.size();
    res.insert(res.end(), blob2.begin(), blob2.end());

-    for (std::size_t i = 0; i < res.size(); ++i) {
-        const auto common = i < idx;
-        const auto pair = ParseTicket(res[i], rsa_key);
+    for (const auto& raw : res) {
+        const auto pair = ParseTicket(raw, rsa_key);
        if (!pair)
            continue;
        const auto& [rid, key] = *pair;
        u128 rights_id;
        std::memcpy(rights_id.data(), rid.data(), rid.size());
-
-        if (common) {
-            common_tickets[rights_id] = res[i];
-        } else {
-            personal_tickets[rights_id] = res[i];
-        }
-
        SetKey(S128KeyType::Titlekey, key, rights_id[1], rights_id[0]);
    }
 }

-void KeyManager::SynthesizeTickets() {
-    for (const auto& key : s128_keys) {
-        if (key.first.type != S128KeyType::Titlekey) {
-            continue;
-        }
-        u128 rights_id{key.first.field1, key.first.field2};
-        Key128 rights_id_2;
-        std::memcpy(rights_id_2.data(), rights_id.data(), rights_id_2.size());
-        const auto ticket = Ticket::SynthesizeCommon(key.second, rights_id_2);
-        common_tickets.insert_or_assign(rights_id, ticket);
-    }
-}
-
 void KeyManager::SetKeyWrapped(S128KeyType id, Key128 key, u64 field1, u64 field2) {
    if (key == Key128{})
        return;
@@ -1130,46 +997,6 @@ void KeyManager::PopulateFromPartitionData(PartitionDataManager& data) {
    DeriveBase();
 }

-const std::map<u128, Ticket>& KeyManager::GetCommonTickets() const {
-    return common_tickets;
-}
-
-const std::map<u128, Ticket>& KeyManager::GetPersonalizedTickets() const {
-    return personal_tickets;
-}
-
-bool KeyManager::AddTicketCommon(Ticket raw) {
-    const auto rsa_key = GetETicketRSAKey();
-    if (rsa_key == RSAKeyPair<2048>{})
-        return false;
-
-    const auto pair = ParseTicket(raw, rsa_key);
-    if (!pair)
-        return false;
-    const auto& [rid, key] = *pair;
-    u128 rights_id;
-    std::memcpy(rights_id.data(), rid.data(), rid.size());
-    common_tickets[rights_id] = raw;
-    SetKey(S128KeyType::Titlekey, key, rights_id[1], rights_id[0]);
-    return true;
-}
-
-bool KeyManager::AddTicketPersonalized(Ticket raw) {
-    const auto rsa_key = GetETicketRSAKey();
-    if (rsa_key == RSAKeyPair<2048>{})
-        return false;
-
-    const auto pair = ParseTicket(raw, rsa_key);
-    if (!pair)
-        return false;
-    const auto& [rid, key] = *pair;
-    u128 rights_id;
-    std::memcpy(rights_id.data(), rid.data(), rid.size());
-    common_tickets[rights_id] = raw;
-    SetKey(S128KeyType::Titlekey, key, rights_id[1], rights_id[0]);
-    return true;
-}
-
 const boost::container::flat_map<std::string, KeyIndex<S128KeyType>> KeyManager::s128_file_id = {
    {"eticket_rsa_kek", {S128KeyType::ETicketRSAKek, 0, 0}},
    {"eticket_rsa_kek_source",
@@ -9,10 +9,8 @@
 #include <optional>
 #include <string>

-#include <variant>
 #include <boost/container/flat_map.hpp>
 #include <fmt/format.h>
-#include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "core/crypto/partition_data_manager.h"
 #include "core/file_sys/vfs_types.h"
@@ -32,79 +30,7 @@ constexpr u64 TICKET_FILE_TITLEKEY_OFFSET = 0x180;
 using Key128 = std::array<u8, 0x10>;
 using Key256 = std::array<u8, 0x20>;
 using SHA256Hash = std::array<u8, 0x20>;
-
-enum class SignatureType {
-    RSA_4096_SHA1 = 0x10000,
-    RSA_2048_SHA1 = 0x10001,
-    ECDSA_SHA1 = 0x10002,
-    RSA_4096_SHA256 = 0x10003,
-    RSA_2048_SHA256 = 0x10004,
-    ECDSA_SHA256 = 0x10005,
-};
-
-u64 GetSignatureTypeDataSize(SignatureType type);
-u64 GetSignatureTypePaddingSize(SignatureType type);
-
-enum class TitleKeyType : u8 {
-    Common = 0,
-    Personalized = 1,
-};
-
-struct TicketData {
-    std::array<u8, 0x40> issuer;
-    union {
-        std::array<u8, 0x100> title_key_block;
-
-        struct {
-            Key128 title_key_common;
-            std::array<u8, 0xF0> title_key_common_pad;
-        };
-    };
-
-    INSERT_PADDING_BYTES(0x1);
-    TitleKeyType type;
-    INSERT_PADDING_BYTES(0x3);
-    u8 revision;
-    INSERT_PADDING_BYTES(0xA);
-    u64 ticket_id;
-    u64 device_id;
-    std::array<u8, 0x10> rights_id;
-    u32 account_id;
-    INSERT_PADDING_BYTES(0x14C);
-};
-static_assert(sizeof(TicketData) == 0x2C0, "TicketData has incorrect size.");
-
-struct RSA4096Ticket {
-    SignatureType sig_type;
-    std::array<u8, 0x200> sig_data;
-    INSERT_PADDING_BYTES(0x3C);
-    TicketData data;
-};
-
-struct RSA2048Ticket {
-    SignatureType sig_type;
-    std::array<u8, 0x100> sig_data;
-    INSERT_PADDING_BYTES(0x3C);
-    TicketData data;
-};
-
-struct ECDSATicket {
-    SignatureType sig_type;
-    std::array<u8, 0x3C> sig_data;
-    INSERT_PADDING_BYTES(0x40);
-    TicketData data;
-};
-
-struct Ticket {
-    std::variant<RSA4096Ticket, RSA2048Ticket, ECDSATicket> data;
-
-    SignatureType GetSignatureType() const;
-    TicketData& GetData();
-    const TicketData& GetData() const;
-    u64 GetSize() const;
-
-    static Ticket SynthesizeCommon(Key128 title_key, const std::array<u8, 0x10>& rights_id);
-};
+using TicketRaw = std::array<u8, 0x400>;

 static_assert(sizeof(Key128) == 16, "Key128 must be 128 bytes big.");
 static_assert(sizeof(Key256) == 32, "Key256 must be 256 bytes big.");
@@ -117,19 +43,6 @@ struct RSAKeyPair {
    std::array<u8, 4> exponent;
 };

-template <size_t bit_size, size_t byte_size>
-bool operator==(const RSAKeyPair<bit_size, byte_size>& lhs,
-                const RSAKeyPair<bit_size, byte_size>& rhs) {
-    return std::tie(lhs.encryption_key, lhs.decryption_key, lhs.modulus, lhs.exponent) ==
-           std::tie(rhs.encryption_key, rhs.decryption_key, rhs.modulus, rhs.exponent);
-}
-
-template <size_t bit_size, size_t byte_size>
-bool operator!=(const RSAKeyPair<bit_size, byte_size>& lhs,
-                const RSAKeyPair<bit_size, byte_size>& rhs) {
-    return !(lhs == rhs);
-}
-
 enum class KeyCategory : u8 {
    Standard,
    Title,
@@ -238,35 +151,22 @@ public:

    static bool KeyFileExists(bool title);

-    // Call before using the sd seed to attempt to derive it if it dosen't exist. Needs system
-    // save 8*43 and the private file to exist.
+    // Call before using the sd seed to attempt to derive it if it dosen't exist. Needs system save
+    // 8*43 and the private file to exist.
    void DeriveSDSeedLazy();

    bool BaseDeriveNecessary() const;
    void DeriveBase();
    void DeriveETicket(PartitionDataManager& data);
-    void PopulateTickets();
-    void SynthesizeTickets();

    void PopulateFromPartitionData(PartitionDataManager& data);

-    const std::map<u128, Ticket>& GetCommonTickets() const;
-    const std::map<u128, Ticket>& GetPersonalizedTickets() const;
-
-    bool AddTicketCommon(Ticket raw);
-    bool AddTicketPersonalized(Ticket raw);
-
 private:
    std::map<KeyIndex<S128KeyType>, Key128> s128_keys;
    std::map<KeyIndex<S256KeyType>, Key256> s256_keys;

-    // Map from rights ID to ticket
-    std::map<u128, Ticket> common_tickets;
-    std::map<u128, Ticket> personal_tickets;
-
    std::array<std::array<u8, 0xB0>, 0x20> encrypted_keyblobs{};
    std::array<std::array<u8, 0x90>, 0x20> keyblobs{};
-    std::array<u8, 576> eticket_extended_kek{};

    bool dev_mode;
    void LoadFromFile(const std::string& filename, bool is_title_keys);
@@ -278,8 +178,6 @@ private:

    void DeriveGeneralPurposeKeys(std::size_t crypto_revision);

-    RSAKeyPair<2048> GetETicketRSAKey() const;
-
    void SetKeyWrapped(S128KeyType id, Key128 key, u64 field1 = 0, u64 field2 = 0);
    void SetKeyWrapped(S256KeyType id, Key256 key, u64 field1 = 0, u64 field2 = 0);

@@ -297,11 +195,11 @@ std::array<u8, 0x90> DecryptKeyblob(const std::array<u8, 0xB0>& encrypted_keyblo
 std::optional<Key128> DeriveSDSeed();
 Loader::ResultStatus DeriveSDKeys(std::array<Key256, 2>& sd_keys, KeyManager& keys);

-std::vector<Ticket> GetTicketblob(const FileUtil::IOFile& ticket_save);
+std::vector<TicketRaw> GetTicketblob(const FileUtil::IOFile& ticket_save);

-// Returns a pair of {rights_id, titlekey}. Fails if the ticket has no certificate authority
-// (offset 0x140-0x144 is zero)
-std::optional<std::pair<Key128, Key128>> ParseTicket(const Ticket& ticket,
+// Returns a pair of {rights_id, titlekey}. Fails if the ticket has no certificate authority (offset
+// 0x140-0x144 is zero)
+std::optional<std::pair<Key128, Key128>> ParseTicket(const TicketRaw& ticket,
                                                     const RSAKeyPair<2048>& eticket_extended_key);

 } // namespace Core::Crypto
@@ -1,46 +0,0 @@
-// Copyright 2019 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/file_sys/system_archive/mii_model.h"
-#include "core/file_sys/vfs_vector.h"
-
-namespace FileSys::SystemArchive {
-
-namespace MiiModelData {
-
-constexpr std::array<u8, 0x10> NFTR_STANDARD{'N',  'F',  'T',  'R',  0x01, 0x00, 0x00, 0x00,
-                                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-constexpr std::array<u8, 0x10> NFSR_STANDARD{'N',  'F',  'S',  'R',  0x01, 0x00, 0x00, 0x00,
-                                             0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-
-constexpr auto TEXTURE_LOW_LINEAR = NFTR_STANDARD;
-constexpr auto TEXTURE_LOW_SRGB = NFTR_STANDARD;
-constexpr auto TEXTURE_MID_LINEAR = NFTR_STANDARD;
-constexpr auto TEXTURE_MID_SRGB = NFTR_STANDARD;
-constexpr auto SHAPE_HIGH = NFSR_STANDARD;
-constexpr auto SHAPE_MID = NFSR_STANDARD;
-
-} // namespace MiiModelData
-
-VirtualDir MiiModel() {
-    auto out = std::make_shared<VectorVfsDirectory>(std::vector<VirtualFile>{},
-                                                    std::vector<VirtualDir>{}, "data");
-
-    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::TEXTURE_LOW_LINEAR.size()>>(
-        MiiModelData::TEXTURE_LOW_LINEAR, "NXTextureLowLinear.dat"));
-    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::TEXTURE_LOW_SRGB.size()>>(
-        MiiModelData::TEXTURE_LOW_SRGB, "NXTextureLowSRGB.dat"));
-    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::TEXTURE_MID_LINEAR.size()>>(
-        MiiModelData::TEXTURE_MID_LINEAR, "NXTextureMidLinear.dat"));
-    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::TEXTURE_MID_SRGB.size()>>(
-        MiiModelData::TEXTURE_MID_SRGB, "NXTextureMidSRGB.dat"));
-    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::SHAPE_HIGH.size()>>(
-        MiiModelData::SHAPE_HIGH, "ShapeHigh.dat"));
-    out->AddFile(std::make_shared<ArrayVfsFile<MiiModelData::SHAPE_MID.size()>>(
-        MiiModelData::SHAPE_MID, "ShapeMid.dat"));
-
-    return std::move(out);
-}
-
-} // namespace FileSys::SystemArchive
@@ -1,13 +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/file_sys/vfs_types.h"
-
-namespace FileSys::SystemArchive {
-
-VirtualDir MiiModel();
-
-} // namespace FileSys::SystemArchive
@@ -4,7 +4,6 @@

 #include "common/logging/log.h"
 #include "core/file_sys/romfs.h"
-#include "core/file_sys/system_archive/mii_model.h"
 #include "core/file_sys/system_archive/ng_word.h"
 #include "core/file_sys/system_archive/system_archive.h"
 #include "core/file_sys/system_archive/system_version.h"
@@ -25,7 +24,7 @@ struct SystemArchiveDescriptor {
 constexpr std::array<SystemArchiveDescriptor, SYSTEM_ARCHIVE_COUNT> SYSTEM_ARCHIVES{{
    {0x0100000000000800, "CertStore", nullptr},
    {0x0100000000000801, "ErrorMessage", nullptr},
-    {0x0100000000000802, "MiiModel", &MiiModel},
+    {0x0100000000000802, "MiiModel", nullptr},
    {0x0100000000000803, "BrowserDll", nullptr},
    {0x0100000000000804, "Help", nullptr},
    {0x0100000000000805, "SharedFont", nullptr},
@@ -296,6 +296,12 @@ ResultVal<VAddr> VMManager::SetHeapSize(u64 size) {
 }

 ResultCode VMManager::MapPhysicalMemory(VAddr target, u64 size) {
+    const auto end_addr = target + size;
+    const auto last_addr = end_addr - 1;
+    VAddr cur_addr = target;
+
+    ResultCode result = RESULT_SUCCESS;
+
    // Check how much memory we've already mapped.
    const auto mapped_size_result = SizeOfAllocatedVMAsInRange(target, size);
    if (mapped_size_result.Failed()) {
@@ -318,16 +324,13 @@ ResultCode VMManager::MapPhysicalMemory(VAddr target, u64 size) {

    // Keep track of the memory regions we unmap.
    std::vector<std::pair<u64, u64>> mapped_regions;
-    ResultCode result = RESULT_SUCCESS;

    // Iterate, trying to map memory.
    {
-        const auto end_addr = target + size;
-        const auto last_addr = end_addr - 1;
-        VAddr cur_addr = target;
+        cur_addr = target;

        auto iter = FindVMA(target);
-        ASSERT(iter != vma_map.end());
+        ASSERT_MSG(iter != vma_map.end(), "MapPhysicalMemory iter != end");

        while (true) {
            const auto& vma = iter->second;
@@ -339,7 +342,7 @@ ResultCode VMManager::MapPhysicalMemory(VAddr target, u64 size) {
            const auto map_size = std::min(end_addr - cur_addr, vma_end - cur_addr);
            if (vma.state == MemoryState::Unmapped) {
                const auto map_res =
-                    MapMemoryBlock(cur_addr, std::make_shared<PhysicalMemory>(map_size), 0,
+                    MapMemoryBlock(cur_addr, std::make_shared<PhysicalMemory>(map_size, 0), 0,
                                   map_size, MemoryState::Heap, VMAPermission::ReadWrite);
                result = map_res.Code();
                if (result.IsError()) {
@@ -357,7 +360,7 @@ ResultCode VMManager::MapPhysicalMemory(VAddr target, u64 size) {
            // Advance to the next block.
            cur_addr = vma_end;
            iter = FindVMA(cur_addr);
-            ASSERT(iter != vma_map.end());
+            ASSERT_MSG(iter != vma_map.end(), "MapPhysicalMemory iter != end");
        }
    }

@@ -365,7 +368,7 @@ ResultCode VMManager::MapPhysicalMemory(VAddr target, u64 size) {
    if (result.IsError()) {
        for (const auto [unmap_address, unmap_size] : mapped_regions) {
            ASSERT_MSG(UnmapRange(unmap_address, unmap_size).IsSuccess(),
-                       "Failed to unmap memory range.");
+                       "MapPhysicalMemory un-map on error");
        }

        return result;
@@ -378,6 +381,12 @@ ResultCode VMManager::MapPhysicalMemory(VAddr target, u64 size) {
 }

 ResultCode VMManager::UnmapPhysicalMemory(VAddr target, u64 size) {
+    const auto end_addr = target + size;
+    const auto last_addr = end_addr - 1;
+    VAddr cur_addr = target;
+
+    ResultCode result = RESULT_SUCCESS;
+
    // Check how much memory is currently mapped.
    const auto mapped_size_result = SizeOfUnmappablePhysicalMemoryInRange(target, size);
    if (mapped_size_result.Failed()) {
@@ -392,16 +401,13 @@ ResultCode VMManager::UnmapPhysicalMemory(VAddr target, u64 size) {

    // Keep track of the memory regions we unmap.
    std::vector<std::pair<u64, u64>> unmapped_regions;
-    ResultCode result = RESULT_SUCCESS;

    // Try to unmap regions.
    {
-        const auto end_addr = target + size;
-        const auto last_addr = end_addr - 1;
-        VAddr cur_addr = target;
+        cur_addr = target;

        auto iter = FindVMA(target);
-        ASSERT(iter != vma_map.end());
+        ASSERT_MSG(iter != vma_map.end(), "UnmapPhysicalMemory iter != end");

        while (true) {
            const auto& vma = iter->second;
@@ -428,7 +434,7 @@ ResultCode VMManager::UnmapPhysicalMemory(VAddr target, u64 size) {
            // Advance to the next block.
            cur_addr = vma_end;
            iter = FindVMA(cur_addr);
-            ASSERT(iter != vma_map.end());
+            ASSERT_MSG(iter != vma_map.end(), "UnmapPhysicalMemory iter != end");
        }
    }

@@ -437,12 +443,10 @@ ResultCode VMManager::UnmapPhysicalMemory(VAddr target, u64 size) {
    if (result.IsError()) {
        for (const auto [map_address, map_size] : unmapped_regions) {
            const auto remap_res =
-                MapMemoryBlock(map_address, std::make_shared<PhysicalMemory>(map_size), 0, map_size,
-                               MemoryState::Heap, VMAPermission::None);
-            ASSERT_MSG(remap_res.Succeeded(), "Failed to remap a memory block.");
+                MapMemoryBlock(map_address, std::make_shared<PhysicalMemory>(map_size, 0), 0,
+                               map_size, MemoryState::Heap, VMAPermission::None);
+            ASSERT_MSG(remap_res.Succeeded(), "UnmapPhysicalMemory re-map on error");
        }
-
-        return result;
    }

    // Update mapped amount
@@ -753,26 +757,20 @@ void VMManager::MergeAdjacentVMA(VirtualMemoryArea& left, const VirtualMemoryAre
    // Always merge allocated memory blocks, even when they don't share the same backing block.
    if (left.type == VMAType::AllocatedMemoryBlock &&
        (left.backing_block != right.backing_block || left.offset + left.size != right.offset)) {
-        const auto right_begin = right.backing_block->begin() + right.offset;
-        const auto right_end = right_begin + right.size;
-
        // Check if we can save work.
        if (left.offset == 0 && left.size == left.backing_block->size()) {
            // Fast case: left is an entire backing block.
-            left.backing_block->insert(left.backing_block->end(), right_begin, right_end);
+            left.backing_block->insert(left.backing_block->end(),
+                                       right.backing_block->begin() + right.offset,
+                                       right.backing_block->begin() + right.offset + right.size);
        } else {
            // Slow case: make a new memory block for left and right.
-            const auto left_begin = left.backing_block->begin() + left.offset;
-            const auto left_end = left_begin + left.size;
-            const auto left_size = static_cast<std::size_t>(std::distance(left_begin, left_end));
-            const auto right_size = static_cast<std::size_t>(std::distance(right_begin, right_end));
-
            auto new_memory = std::make_shared<PhysicalMemory>();
-            new_memory->reserve(left_size + right_size);
-            new_memory->insert(new_memory->end(), left_begin, left_end);
-            new_memory->insert(new_memory->end(), right_begin, right_end);
-
-            left.backing_block = std::move(new_memory);
+            new_memory->insert(new_memory->end(), left.backing_block->begin() + left.offset,
+                               left.backing_block->begin() + left.offset + left.size);
+            new_memory->insert(new_memory->end(), right.backing_block->begin() + right.offset,
+                               right.backing_block->begin() + right.offset + right.size);
+            left.backing_block = new_memory;
            left.offset = 0;
        }

@@ -967,7 +965,7 @@ ResultVal<std::size_t> VMManager::SizeOfAllocatedVMAsInRange(VAddr address,

    VAddr cur_addr = address;
    auto iter = FindVMA(cur_addr);
-    ASSERT(iter != vma_map.end());
+    ASSERT_MSG(iter != vma_map.end(), "SizeOfAllocatedVMAsInRange iter != end");

    while (true) {
        const auto& vma = iter->second;
@@ -988,7 +986,7 @@ ResultVal<std::size_t> VMManager::SizeOfAllocatedVMAsInRange(VAddr address,
        // Advance to the next block.
        cur_addr = vma_end;
        iter = std::next(iter);
-        ASSERT(iter != vma_map.end());
+        ASSERT_MSG(iter != vma_map.end(), "SizeOfAllocatedVMAsInRange iter != end");
    }

    return MakeResult(mapped_size);
@@ -1002,7 +1000,7 @@ ResultVal<std::size_t> VMManager::SizeOfUnmappablePhysicalMemoryInRange(VAddr ad

    VAddr cur_addr = address;
    auto iter = FindVMA(cur_addr);
-    ASSERT(iter != vma_map.end());
+    ASSERT_MSG(iter != vma_map.end(), "SizeOfUnmappablePhysicalMemoryInRange iter != end");

    while (true) {
        const auto& vma = iter->second;
@@ -1031,7 +1029,7 @@ ResultVal<std::size_t> VMManager::SizeOfUnmappablePhysicalMemoryInRange(VAddr ad
        // Advance to the next block.
        cur_addr = vma_end;
        iter = std::next(iter);
-        ASSERT(iter != vma_map.end());
+        ASSERT_MSG(iter != vma_map.end(), "SizeOfUnmappablePhysicalMemoryInRange iter != end");
    }

    return MakeResult(mapped_size);
@@ -454,8 +454,8 @@ public:

    /// Maps memory at a given address.
    ///
-    /// @param target The virtual address to map memory at.
-    /// @param size   The amount of memory to map.
+    /// @param addr The virtual address to map memory at.
+    /// @param size The amount of memory to map.
    ///
    /// @note The destination address must lie within the Map region.
    ///
@@ -468,8 +468,8 @@ public:

    /// Unmaps memory at a given address.
    ///
-    /// @param target The virtual address to unmap memory at.
-    /// @param size   The amount of memory to unmap.
+    /// @param addr The virtual address to unmap memory at.
+    /// @param size The amount of memory to unmap.
    ///
    /// @note The destination address must lie within the Map region.
    ///
@@ -31,9 +31,6 @@

 namespace Service::Account {

-constexpr ResultCode ERR_INVALID_BUFFER_SIZE{ErrorModule::Account, 30};
-constexpr ResultCode ERR_FAILED_SAVE_DATA{ErrorModule::Account, 100};
-
 static std::string GetImagePath(Common::UUID uuid) {
    return FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
           "/system/save/8000000000000010/su/avators/" + uuid.FormatSwitch() + ".jpg";
@@ -44,31 +41,20 @@ static constexpr u32 SanitizeJPEGSize(std::size_t size) {
    return static_cast<u32>(std::min(size, max_jpeg_image_size));
 }

-class IProfileCommon : public ServiceFramework<IProfileCommon> {
+class IProfile final : public ServiceFramework<IProfile> {
 public:
-    explicit IProfileCommon(const char* name, bool editor_commands, Common::UUID user_id,
-                            ProfileManager& profile_manager)
-        : ServiceFramework(name), profile_manager(profile_manager), user_id(user_id) {
+    explicit IProfile(Common::UUID user_id, ProfileManager& profile_manager)
+        : ServiceFramework("IProfile"), profile_manager(profile_manager), user_id(user_id) {
        static const FunctionInfo functions[] = {
-            {0, &IProfileCommon::Get, "Get"},
-            {1, &IProfileCommon::GetBase, "GetBase"},
-            {10, &IProfileCommon::GetImageSize, "GetImageSize"},
-            {11, &IProfileCommon::LoadImage, "LoadImage"},
+            {0, &IProfile::Get, "Get"},
+            {1, &IProfile::GetBase, "GetBase"},
+            {10, &IProfile::GetImageSize, "GetImageSize"},
+            {11, &IProfile::LoadImage, "LoadImage"},
        };
-
        RegisterHandlers(functions);
-
-        if (editor_commands) {
-            static const FunctionInfo editor_functions[] = {
-                {100, &IProfileCommon::Store, "Store"},
-                {101, &IProfileCommon::StoreWithImage, "StoreWithImage"},
-            };
-
-            RegisterHandlers(editor_functions);
-        }
    }

-protected:
+private:
    void Get(Kernel::HLERequestContext& ctx) {
        LOG_INFO(Service_ACC, "called user_id={}", user_id.Format());
        ProfileBase profile_base{};
@@ -141,91 +127,10 @@ protected:
        }
    }

-    void Store(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto base = rp.PopRaw<ProfileBase>();
-
-        const auto user_data = ctx.ReadBuffer();
-
-        LOG_DEBUG(Service_ACC, "called, username='{}', timestamp={:016X}, uuid={}",
-                  Common::StringFromFixedZeroTerminatedBuffer(
-                      reinterpret_cast<const char*>(base.username.data()), base.username.size()),
-                  base.timestamp, base.user_uuid.Format());
-
-        if (user_data.size() < sizeof(ProfileData)) {
-            LOG_ERROR(Service_ACC, "ProfileData buffer too small!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_INVALID_BUFFER_SIZE);
-            return;
-        }
-
-        ProfileData data;
-        std::memcpy(&data, user_data.data(), sizeof(ProfileData));
-
-        if (!profile_manager.SetProfileBaseAndData(user_id, base, data)) {
-            LOG_ERROR(Service_ACC, "Failed to update profile data and base!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_FAILED_SAVE_DATA);
-            return;
-        }
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void StoreWithImage(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto base = rp.PopRaw<ProfileBase>();
-
-        const auto user_data = ctx.ReadBuffer();
-        const auto image_data = ctx.ReadBuffer(1);
-
-        LOG_DEBUG(Service_ACC, "called, username='{}', timestamp={:016X}, uuid={}",
-                  Common::StringFromFixedZeroTerminatedBuffer(
-                      reinterpret_cast<const char*>(base.username.data()), base.username.size()),
-                  base.timestamp, base.user_uuid.Format());
-
-        if (user_data.size() < sizeof(ProfileData)) {
-            LOG_ERROR(Service_ACC, "ProfileData buffer too small!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_INVALID_BUFFER_SIZE);
-            return;
-        }
-
-        ProfileData data;
-        std::memcpy(&data, user_data.data(), sizeof(ProfileData));
-
-        FileUtil::IOFile image(GetImagePath(user_id), "wb");
-
-        if (!image.IsOpen() || !image.Resize(image_data.size()) ||
-            image.WriteBytes(image_data.data(), image_data.size()) != image_data.size() ||
-            !profile_manager.SetProfileBaseAndData(user_id, base, data)) {
-            LOG_ERROR(Service_ACC, "Failed to update profile data, base, and image!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERR_FAILED_SAVE_DATA);
-            return;
-        }
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    ProfileManager& profile_manager;
+    const ProfileManager& profile_manager;
    Common::UUID user_id; ///< The user id this profile refers to.
 };

-class IProfile final : public IProfileCommon {
-public:
-    IProfile(Common::UUID user_id, ProfileManager& profile_manager)
-        : IProfileCommon("IProfile", false, user_id, profile_manager) {}
-};
-
-class IProfileEditor final : public IProfileCommon {
-public:
-    IProfileEditor(Common::UUID user_id, ProfileManager& profile_manager)
-        : IProfileCommon("IProfileEditor", true, user_id, profile_manager) {}
-};
-
 class IManagerForApplication final : public ServiceFramework<IManagerForApplication> {
 public:
    IManagerForApplication() : ServiceFramework("IManagerForApplication") {
@@ -417,17 +322,6 @@ void Module::Interface::IsUserAccountSwitchLocked(Kernel::HLERequestContext& ctx
    rb.Push(is_locked);
 }

-void Module::Interface::GetProfileEditor(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    Common::UUID user_id = rp.PopRaw<Common::UUID>();
-
-    LOG_DEBUG(Service_ACC, "called, user_id={}", user_id.Format());
-
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushIpcInterface<IProfileEditor>(user_id, *profile_manager);
-}
-
 void Module::Interface::TrySelectUserWithoutInteraction(Kernel::HLERequestContext& ctx) {
    LOG_DEBUG(Service_ACC, "called");
    // A u8 is passed into this function which we can safely ignore. It's to determine if we have
@@ -32,7 +32,6 @@ public:
        void IsUserRegistrationRequestPermitted(Kernel::HLERequestContext& ctx);
        void TrySelectUserWithoutInteraction(Kernel::HLERequestContext& ctx);
        void IsUserAccountSwitchLocked(Kernel::HLERequestContext& ctx);
-        void GetProfileEditor(Kernel::HLERequestContext& ctx);

    private:
        ResultCode InitializeApplicationInfoBase(u64 process_id);
@@ -41,7 +41,7 @@ ACC_SU::ACC_SU(std::shared_ptr<Module> module, std::shared_ptr<ProfileManager> p
        {202, nullptr, "CancelUserRegistration"},
        {203, nullptr, "DeleteUser"},
        {204, nullptr, "SetUserPosition"},
-        {205, &ACC_SU::GetProfileEditor, "GetProfileEditor"},
+        {205, nullptr, "GetProfileEditor"},
        {206, nullptr, "CompleteUserRegistrationForcibly"},
        {210, nullptr, "CreateFloatingRegistrationRequest"},
        {230, nullptr, "AuthenticateServiceAsync"},
@@ -305,17 +305,6 @@ bool ProfileManager::SetProfileBase(UUID uuid, const ProfileBase& profile_new) {
    return true;
 }

-bool ProfileManager::SetProfileBaseAndData(Common::UUID uuid, const ProfileBase& profile_new,
-                                           const ProfileData& data_new) {
-    const auto index = GetUserIndex(uuid);
-    if (index.has_value() && SetProfileBase(uuid, profile_new)) {
-        profiles[*index].data = data_new;
-        return true;
-    }
-
-    return false;
-}
-
 void ProfileManager::ParseUserSaveFile() {
    FileUtil::IOFile save(FileUtil::GetUserPath(FileUtil::UserPath::NANDDir) +
                              ACC_SAVE_AVATORS_BASE_PATH + "profiles.dat",
@@ -91,8 +91,6 @@ public:

    bool RemoveUser(Common::UUID uuid);
    bool SetProfileBase(Common::UUID uuid, const ProfileBase& profile_new);
-    bool SetProfileBaseAndData(Common::UUID uuid, const ProfileBase& profile_new,
-                               const ProfileData& data_new);

 private:
    void ParseUserSaveFile();
@@ -56,8 +56,7 @@ struct LaunchParameters {
 };
 static_assert(sizeof(LaunchParameters) == 0x88);

-IWindowController::IWindowController(Core::System& system_)
-    : ServiceFramework("IWindowController"), system{system_} {
+IWindowController::IWindowController() : ServiceFramework("IWindowController") {
    // clang-format off
    static const FunctionInfo functions[] = {
        {0, nullptr, "CreateWindow"},
@@ -76,7 +75,7 @@ IWindowController::IWindowController(Core::System& system_)
 IWindowController::~IWindowController() = default;

 void IWindowController::GetAppletResourceUserId(Kernel::HLERequestContext& ctx) {
-    const u64 process_id = system.CurrentProcess()->GetProcessID();
+    const u64 process_id = Core::System::GetInstance().Kernel().CurrentProcess()->GetProcessID();

    LOG_DEBUG(Service_AM, "called. Process ID=0x{:016X}", process_id);

@@ -232,9 +231,8 @@ IDebugFunctions::IDebugFunctions() : ServiceFramework{"IDebugFunctions"} {

 IDebugFunctions::~IDebugFunctions() = default;

-ISelfController::ISelfController(Core::System& system_,
-                                 std::shared_ptr<NVFlinger::NVFlinger> nvflinger_)
-    : ServiceFramework("ISelfController"), nvflinger(std::move(nvflinger_)) {
+ISelfController::ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger)
+    : ServiceFramework("ISelfController"), nvflinger(std::move(nvflinger)) {
    // clang-format off
    static const FunctionInfo functions[] = {
        {0, nullptr, "Exit"},
@@ -282,7 +280,7 @@ ISelfController::ISelfController(Core::System& system_,

    RegisterHandlers(functions);

-    auto& kernel = system_.Kernel();
+    auto& kernel = Core::System::GetInstance().Kernel();
    launchable_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Manual,
                                                              "ISelfController:LaunchableEvent");

@@ -503,7 +501,8 @@ void ISelfController::GetAccumulatedSuspendedTickChangedEvent(Kernel::HLERequest
    rb.PushCopyObjects(accumulated_suspended_tick_changed_event.readable);
 }

-AppletMessageQueue::AppletMessageQueue(Kernel::KernelCore& kernel) {
+AppletMessageQueue::AppletMessageQueue() {
+    auto& kernel = Core::System::GetInstance().Kernel();
    on_new_message = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Manual,
                                                            "AMMessageQueue:OnMessageRecieved");
    on_operation_mode_changed = Kernel::WritableEvent::CreateEventPair(
@@ -938,8 +937,9 @@ void IStorageAccessor::Read(Kernel::HLERequestContext& ctx) {
    rb.Push(RESULT_SUCCESS);
 }

-ILibraryAppletCreator::ILibraryAppletCreator(Core::System& system_)
-    : ServiceFramework("ILibraryAppletCreator"), system{system_} {
+ILibraryAppletCreator::ILibraryAppletCreator(u64 current_process_title_id)
+    : ServiceFramework("ILibraryAppletCreator"),
+      current_process_title_id(current_process_title_id) {
    static const FunctionInfo functions[] = {
        {0, &ILibraryAppletCreator::CreateLibraryApplet, "CreateLibraryApplet"},
        {1, nullptr, "TerminateAllLibraryApplets"},
@@ -961,8 +961,8 @@ void ILibraryAppletCreator::CreateLibraryApplet(Kernel::HLERequestContext& ctx)
    LOG_DEBUG(Service_AM, "called with applet_id={:08X}, applet_mode={:08X}",
              static_cast<u32>(applet_id), applet_mode);

-    const auto& applet_manager{system.GetAppletManager()};
-    const auto applet = applet_manager.GetApplet(applet_id);
+    const auto& applet_manager{Core::System::GetInstance().GetAppletManager()};
+    const auto applet = applet_manager.GetApplet(applet_id, current_process_title_id);

    if (applet == nullptr) {
        LOG_ERROR(Service_AM, "Applet doesn't exist! applet_id={}", static_cast<u32>(applet_id));
@@ -999,7 +999,8 @@ void ILibraryAppletCreator::CreateTransferMemoryStorage(Kernel::HLERequestContex
    const auto handle{rp.Pop<Kernel::Handle>()};

    const auto transfer_mem =
-        system.CurrentProcess()->GetHandleTable().Get<Kernel::TransferMemory>(handle);
+        Core::System::GetInstance().CurrentProcess()->GetHandleTable().Get<Kernel::TransferMemory>(
+            handle);

    if (transfer_mem == nullptr) {
        LOG_ERROR(Service_AM, "shared_mem is a nullpr for handle={:08X}", handle);
@@ -1017,8 +1018,7 @@ void ILibraryAppletCreator::CreateTransferMemoryStorage(Kernel::HLERequestContex
    rb.PushIpcInterface(std::make_shared<IStorage>(std::move(memory)));
 }

-IApplicationFunctions::IApplicationFunctions(Core::System& system_)
-    : ServiceFramework("IApplicationFunctions"), system{system_} {
+IApplicationFunctions::IApplicationFunctions() : ServiceFramework("IApplicationFunctions") {
    // clang-format off
    static const FunctionInfo functions[] = {
        {1, &IApplicationFunctions::PopLaunchParameter, "PopLaunchParameter"},
@@ -1057,7 +1057,6 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)
        {120, nullptr, "ExecuteProgram"},
        {121, nullptr, "ClearUserChannel"},
        {122, nullptr, "UnpopToUserChannel"},
-        {130, &IApplicationFunctions::GetGpuErrorDetectedSystemEvent, "GetGpuErrorDetectedSystemEvent"},
        {500, nullptr, "StartContinuousRecordingFlushForDebug"},
        {1000, nullptr, "CreateMovieMaker"},
        {1001, nullptr, "PrepareForJit"},
@@ -1065,10 +1064,6 @@ IApplicationFunctions::IApplicationFunctions(Core::System& system_)
    // clang-format on

    RegisterHandlers(functions);
-
-    auto& kernel = Core::System::GetInstance().Kernel();
-    gpu_error_detected_event = Kernel::WritableEvent::CreateEventPair(
-        kernel, Kernel::ResetType::Manual, "IApplicationFunctions:GpuErrorDetectedSystemEvent");
 }

 IApplicationFunctions::~IApplicationFunctions() = default;
@@ -1180,7 +1175,7 @@ void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
    // Get supported languages from NACP, if possible
    // Default to 0 (all languages supported)
    u32 supported_languages = 0;
-    FileSys::PatchManager pm{system.CurrentProcess()->GetTitleID()};
+    FileSys::PatchManager pm{Core::System::GetInstance().CurrentProcess()->GetTitleID()};

    const auto res = pm.GetControlMetadata();
    if (res.first != nullptr) {
@@ -1188,8 +1183,8 @@ void IApplicationFunctions::GetDesiredLanguage(Kernel::HLERequestContext& ctx) {
    }

    // Call IApplicationManagerInterface implementation.
-    auto& service_manager = system.ServiceManager();
-    auto ns_am2 = service_manager.GetService<NS::NS>("ns:am2");
+    auto& service_manager = Core::System::GetInstance().ServiceManager();
+    auto ns_am2 = service_manager.GetService<Service::NS::NS>("ns:am2");
    auto app_man = ns_am2->GetApplicationManagerInterface();

    // Get desired application language
@@ -1261,8 +1256,8 @@ void IApplicationFunctions::ExtendSaveData(Kernel::HLERequestContext& ctx) {
              "new_journal={:016X}",
              static_cast<u8>(type), user_id[1], user_id[0], new_normal_size, new_journal_size);

-    const auto title_id = system.CurrentProcess()->GetTitleID();
-    FileSystem::WriteSaveDataSize(type, title_id, user_id, {new_normal_size, new_journal_size});
+    FileSystem::WriteSaveDataSize(type, Core::CurrentProcess()->GetTitleID(), user_id,
+                                  {new_normal_size, new_journal_size});

    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(RESULT_SUCCESS);
@@ -1281,8 +1276,8 @@ void IApplicationFunctions::GetSaveDataSize(Kernel::HLERequestContext& ctx) {
    LOG_DEBUG(Service_AM, "called with type={:02X}, user_id={:016X}{:016X}", static_cast<u8>(type),
              user_id[1], user_id[0]);

-    const auto title_id = system.CurrentProcess()->GetTitleID();
-    const auto size = FileSystem::ReadSaveDataSize(type, title_id, user_id);
+    const auto size =
+        FileSystem::ReadSaveDataSize(type, Core::CurrentProcess()->GetTitleID(), user_id);

    IPC::ResponseBuilder rb{ctx, 6};
    rb.Push(RESULT_SUCCESS);
@@ -1290,19 +1285,11 @@ void IApplicationFunctions::GetSaveDataSize(Kernel::HLERequestContext& ctx) {
    rb.Push(size.journal);
 }

-void IApplicationFunctions::GetGpuErrorDetectedSystemEvent(Kernel::HLERequestContext& ctx) {
-    LOG_WARNING(Service_AM, "(STUBBED) called");
-
-    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(RESULT_SUCCESS);
-    rb.PushCopyObjects(gpu_error_detected_event.readable);
-}
-
 void InstallInterfaces(SM::ServiceManager& service_manager,
                       std::shared_ptr<NVFlinger::NVFlinger> nvflinger, Core::System& system) {
-    auto message_queue = std::make_shared<AppletMessageQueue>(system.Kernel());
-    // Needed on game boot
-    message_queue->PushMessage(AppletMessageQueue::AppletMessage::FocusStateChanged);
+    auto message_queue = std::make_shared<AppletMessageQueue>();
+    message_queue->PushMessage(AppletMessageQueue::AppletMessage::FocusStateChanged); // Needed on
+                                                                                      // game boot

    std::make_shared<AppletAE>(nvflinger, message_queue, system)->InstallAsService(service_manager);
    std::make_shared<AppletOE>(nvflinger, message_queue, system)->InstallAsService(service_manager);
@@ -10,15 +10,12 @@
 #include "core/hle/kernel/writable_event.h"
 #include "core/hle/service/service.h"

-namespace Kernel {
-class KernelCore;
-}
-
-namespace Service::NVFlinger {
+namespace Service {
+namespace NVFlinger {
 class NVFlinger;
 }

-namespace Service::AM {
+namespace AM {

 enum SystemLanguage {
    Japanese = 0,
@@ -50,7 +47,7 @@ public:
        PerformanceModeChanged = 31,
    };

-    explicit AppletMessageQueue(Kernel::KernelCore& kernel);
+    AppletMessageQueue();
    ~AppletMessageQueue();

    const Kernel::SharedPtr<Kernel::ReadableEvent>& GetMesssageRecieveEvent() const;
@@ -68,14 +65,12 @@ private:

 class IWindowController final : public ServiceFramework<IWindowController> {
 public:
-    explicit IWindowController(Core::System& system_);
+    IWindowController();
    ~IWindowController() override;

 private:
    void GetAppletResourceUserId(Kernel::HLERequestContext& ctx);
    void AcquireForegroundRights(Kernel::HLERequestContext& ctx);
-
-    Core::System& system;
 };

 class IAudioController final : public ServiceFramework<IAudioController> {
@@ -118,8 +113,7 @@ public:

 class ISelfController final : public ServiceFramework<ISelfController> {
 public:
-    explicit ISelfController(Core::System& system_,
-                             std::shared_ptr<NVFlinger::NVFlinger> nvflinger_);
+    explicit ISelfController(std::shared_ptr<NVFlinger::NVFlinger> nvflinger);
    ~ISelfController() override;

 private:
@@ -214,7 +208,7 @@ private:

 class ILibraryAppletCreator final : public ServiceFramework<ILibraryAppletCreator> {
 public:
-    explicit ILibraryAppletCreator(Core::System& system_);
+    ILibraryAppletCreator(u64 current_process_title_id);
    ~ILibraryAppletCreator() override;

 private:
@@ -222,12 +216,12 @@ private:
    void CreateStorage(Kernel::HLERequestContext& ctx);
    void CreateTransferMemoryStorage(Kernel::HLERequestContext& ctx);

-    Core::System& system;
+    u64 current_process_title_id;
 };

 class IApplicationFunctions final : public ServiceFramework<IApplicationFunctions> {
 public:
-    explicit IApplicationFunctions(Core::System& system_);
+    IApplicationFunctions();
    ~IApplicationFunctions() override;

 private:
@@ -248,10 +242,6 @@ private:
    void BeginBlockingHomeButton(Kernel::HLERequestContext& ctx);
    void EndBlockingHomeButton(Kernel::HLERequestContext& ctx);
    void EnableApplicationCrashReport(Kernel::HLERequestContext& ctx);
-    void GetGpuErrorDetectedSystemEvent(Kernel::HLERequestContext& ctx);
-
-    Kernel::EventPair gpu_error_detected_event;
-    Core::System& system;
 };

 class IHomeMenuFunctions final : public ServiceFramework<IHomeMenuFunctions> {
@@ -285,4 +275,5 @@ public:
 void InstallInterfaces(SM::ServiceManager& service_manager,
                       std::shared_ptr<NVFlinger::NVFlinger> nvflinger, Core::System& system);

-} // namespace Service::AM
+} // namespace AM
+} // namespace Service
@@ -50,7 +50,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ISelfController>(system, nvflinger);
+        rb.PushIpcInterface<ISelfController>(nvflinger);
    }

    void GetWindowController(Kernel::HLERequestContext& ctx) {
@@ -58,7 +58,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IWindowController>(system);
+        rb.PushIpcInterface<IWindowController>();
    }

    void GetAudioController(Kernel::HLERequestContext& ctx) {
@@ -98,7 +98,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ILibraryAppletCreator>(system);
+        rb.PushIpcInterface<ILibraryAppletCreator>(system.CurrentProcess()->GetTitleID());
    }

    void GetApplicationFunctions(Kernel::HLERequestContext& ctx) {
@@ -106,7 +106,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IApplicationFunctions>(system);
+        rb.PushIpcInterface<IApplicationFunctions>();
    }

    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
@@ -154,7 +154,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ISelfController>(system, nvflinger);
+        rb.PushIpcInterface<ISelfController>(nvflinger);
    }

    void GetWindowController(Kernel::HLERequestContext& ctx) {
@@ -162,7 +162,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IWindowController>(system);
+        rb.PushIpcInterface<IWindowController>();
    }

    void GetAudioController(Kernel::HLERequestContext& ctx) {
@@ -194,7 +194,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ILibraryAppletCreator>(system);
+        rb.PushIpcInterface<ILibraryAppletCreator>(system.CurrentProcess()->GetTitleID());
    }

    void GetHomeMenuFunctions(Kernel::HLERequestContext& ctx) {
@@ -4,6 +4,7 @@

 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/process.h"
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applet_oe.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
@@ -63,7 +64,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IWindowController>(system);
+        rb.PushIpcInterface<IWindowController>();
    }

    void GetSelfController(Kernel::HLERequestContext& ctx) {
@@ -71,7 +72,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ISelfController>(system, nvflinger);
+        rb.PushIpcInterface<ISelfController>(nvflinger);
    }

    void GetCommonStateGetter(Kernel::HLERequestContext& ctx) {
@@ -87,7 +88,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<ILibraryAppletCreator>(system);
+        rb.PushIpcInterface<ILibraryAppletCreator>(system.CurrentProcess()->GetTitleID());
    }

    void GetApplicationFunctions(Kernel::HLERequestContext& ctx) {
@@ -95,7 +96,7 @@ private:

        IPC::ResponseBuilder rb{ctx, 2, 0, 1};
        rb.Push(RESULT_SUCCESS);
-        rb.PushIpcInterface<IApplicationFunctions>(system);
+        rb.PushIpcInterface<IApplicationFunctions>();
    }

    std::shared_ptr<NVFlinger::NVFlinger> nvflinger;
@@ -23,7 +23,8 @@

 namespace Service::AM::Applets {

-AppletDataBroker::AppletDataBroker(Kernel::KernelCore& kernel) {
+AppletDataBroker::AppletDataBroker() {
+    auto& kernel = Core::System::GetInstance().Kernel();
    state_changed_event = Kernel::WritableEvent::CreateEventPair(
        kernel, Kernel::ResetType::Manual, "ILibraryAppletAccessor:StateChangedEvent");
    pop_out_data_event = Kernel::WritableEvent::CreateEventPair(
@@ -120,7 +121,7 @@ Kernel::SharedPtr<Kernel::ReadableEvent> AppletDataBroker::GetStateChangedEvent(
    return state_changed_event.readable;
 }

-Applet::Applet(Kernel::KernelCore& kernel_) : broker{kernel_} {}
+Applet::Applet() = default;

 Applet::~Applet() = default;

@@ -153,7 +154,7 @@ AppletFrontendSet::AppletFrontendSet(AppletFrontendSet&&) noexcept = default;

 AppletFrontendSet& AppletFrontendSet::operator=(AppletFrontendSet&&) noexcept = default;

-AppletManager::AppletManager(Core::System& system_) : system{system_} {}
+AppletManager::AppletManager() = default;

 AppletManager::~AppletManager() = default;

@@ -215,28 +216,28 @@ void AppletManager::ClearAll() {
    frontend = {};
 }

-std::shared_ptr<Applet> AppletManager::GetApplet(AppletId id) const {
+std::shared_ptr<Applet> AppletManager::GetApplet(AppletId id, u64 current_process_title_id) const {
    switch (id) {
    case AppletId::Auth:
-        return std::make_shared<Auth>(system, *frontend.parental_controls);
+        return std::make_shared<Auth>(*frontend.parental_controls);
    case AppletId::Error:
-        return std::make_shared<Error>(system, *frontend.error);
+        return std::make_shared<Error>(*frontend.error);
    case AppletId::ProfileSelect:
-        return std::make_shared<ProfileSelect>(system, *frontend.profile_select);
+        return std::make_shared<ProfileSelect>(*frontend.profile_select);
    case AppletId::SoftwareKeyboard:
-        return std::make_shared<SoftwareKeyboard>(system, *frontend.software_keyboard);
+        return std::make_shared<SoftwareKeyboard>(*frontend.software_keyboard);
    case AppletId::PhotoViewer:
-        return std::make_shared<PhotoViewer>(system, *frontend.photo_viewer);
+        return std::make_shared<PhotoViewer>(*frontend.photo_viewer);
    case AppletId::LibAppletShop:
-        return std::make_shared<WebBrowser>(system, *frontend.web_browser,
+        return std::make_shared<WebBrowser>(*frontend.web_browser, current_process_title_id,
                                            frontend.e_commerce.get());
    case AppletId::LibAppletOff:
-        return std::make_shared<WebBrowser>(system, *frontend.web_browser);
+        return std::make_shared<WebBrowser>(*frontend.web_browser, current_process_title_id);
    default:
        UNIMPLEMENTED_MSG(
            "No backend implementation exists for applet_id={:02X}! Falling back to stub applet.",
            static_cast<u8>(id));
-        return std::make_shared<StubApplet>(system, id);
+        return std::make_shared<StubApplet>(id);
    }
 }

@@ -12,10 +12,6 @@

 union ResultCode;

-namespace Core {
-class System;
-}
-
 namespace Core::Frontend {
 class ECommerceApplet;
 class ErrorApplet;
@@ -26,10 +22,6 @@ class SoftwareKeyboardApplet;
 class WebBrowserApplet;
 } // namespace Core::Frontend

-namespace Kernel {
-class KernelCore;
-}
-
 namespace Service::AM {

 class IStorage;
@@ -61,7 +53,7 @@ enum class AppletId : u32 {

 class AppletDataBroker final {
 public:
-    explicit AppletDataBroker(Kernel::KernelCore& kernel_);
+    AppletDataBroker();
    ~AppletDataBroker();

    struct RawChannelData {
@@ -116,7 +108,7 @@ private:

 class Applet {
 public:
-    explicit Applet(Kernel::KernelCore& kernel_);
+    Applet();
    virtual ~Applet();

    virtual void Initialize();
@@ -187,7 +179,7 @@ struct AppletFrontendSet {

 class AppletManager {
 public:
-    explicit AppletManager(Core::System& system_);
+    AppletManager();
    ~AppletManager();

    void SetAppletFrontendSet(AppletFrontendSet set);
@@ -195,11 +187,10 @@ public:
    void SetDefaultAppletsIfMissing();
    void ClearAll();

-    std::shared_ptr<Applet> GetApplet(AppletId id) const;
+    std::shared_ptr<Applet> GetApplet(AppletId id, u64 current_process_title_id) const;

 private:
    AppletFrontendSet frontend;
-    Core::System& system;
 };

 } // namespace Applets
@@ -85,8 +85,7 @@ ResultCode Decode64BitError(u64 error) {

 } // Anonymous namespace

-Error::Error(Core::System& system_, const Core::Frontend::ErrorApplet& frontend_)
-    : Applet{system_.Kernel()}, frontend(frontend_), system{system_} {}
+Error::Error(const Core::Frontend::ErrorApplet& frontend) : frontend(frontend) {}

 Error::~Error() = default;

@@ -146,8 +145,8 @@ void Error::Execute() {
    }

    const auto callback = [this] { DisplayCompleted(); };
-    const auto title_id = system.CurrentProcess()->GetTitleID();
-    const auto& reporter{system.GetReporter()};
+    const auto title_id = Core::CurrentProcess()->GetTitleID();
+    const auto& reporter{Core::System::GetInstance().GetReporter()};

    switch (mode) {
    case ErrorAppletMode::ShowError:
@@ -7,10 +7,6 @@
 #include "core/hle/result.h"
 #include "core/hle/service/am/applets/applets.h"

-namespace Core {
-class System;
-}
-
 namespace Service::AM::Applets {

 enum class ErrorAppletMode : u8 {
@@ -25,7 +21,7 @@ enum class ErrorAppletMode : u8 {

 class Error final : public Applet {
 public:
-    explicit Error(Core::System& system_, const Core::Frontend::ErrorApplet& frontend_);
+    explicit Error(const Core::Frontend::ErrorApplet& frontend);
    ~Error() override;

    void Initialize() override;
@@ -46,7 +42,6 @@ private:
    std::unique_ptr<ErrorArguments> args;

    bool complete = false;
-    Core::System& system;
 };

 } // namespace Service::AM::Applets
@@ -37,8 +37,7 @@ static void LogCurrentStorage(AppletDataBroker& broker, std::string_view prefix)
    }
 }

-Auth::Auth(Core::System& system_, Core::Frontend::ParentalControlsApplet& frontend_)
-    : Applet{system_.Kernel()}, frontend(frontend_) {}
+Auth::Auth(Core::Frontend::ParentalControlsApplet& frontend) : frontend(frontend) {}

 Auth::~Auth() = default;

@@ -152,8 +151,7 @@ void Auth::AuthFinished(bool successful) {
    broker.SignalStateChanged();
 }

-PhotoViewer::PhotoViewer(Core::System& system_, const Core::Frontend::PhotoViewerApplet& frontend_)
-    : Applet{system_.Kernel()}, frontend(frontend_), system{system_} {}
+PhotoViewer::PhotoViewer(const Core::Frontend::PhotoViewerApplet& frontend) : frontend(frontend) {}

 PhotoViewer::~PhotoViewer() = default;

@@ -187,7 +185,7 @@ void PhotoViewer::Execute() {
    const auto callback = [this] { ViewFinished(); };
    switch (mode) {
    case PhotoViewerAppletMode::CurrentApp:
-        frontend.ShowPhotosForApplication(system.CurrentProcess()->GetTitleID(), callback);
+        frontend.ShowPhotosForApplication(Core::CurrentProcess()->GetTitleID(), callback);
        break;
    case PhotoViewerAppletMode::AllApps:
        frontend.ShowAllPhotos(callback);
@@ -202,8 +200,7 @@ void PhotoViewer::ViewFinished() {
    broker.SignalStateChanged();
 }

-StubApplet::StubApplet(Core::System& system_, AppletId id_)
-    : Applet{system_.Kernel()}, id(id_), system{system_} {}
+StubApplet::StubApplet(AppletId id) : id(id) {}

 StubApplet::~StubApplet() = default;

@@ -212,7 +209,7 @@ void StubApplet::Initialize() {
    Applet::Initialize();

    const auto data = broker.PeekDataToAppletForDebug();
-    system.GetReporter().SaveUnimplementedAppletReport(
+    Core::System::GetInstance().GetReporter().SaveUnimplementedAppletReport(
        static_cast<u32>(id), common_args.arguments_version, common_args.library_version,
        common_args.theme_color, common_args.play_startup_sound, common_args.system_tick,
        data.normal, data.interactive);
@@ -6,10 +6,6 @@

 #include "core/hle/service/am/applets/applets.h"

-namespace Core {
-class System;
-}
-
 namespace Service::AM::Applets {

 enum class AuthAppletType : u32 {
@@ -20,7 +16,7 @@ enum class AuthAppletType : u32 {

 class Auth final : public Applet {
 public:
-    explicit Auth(Core::System& system_, Core::Frontend::ParentalControlsApplet& frontend_);
+    explicit Auth(Core::Frontend::ParentalControlsApplet& frontend);
    ~Auth() override;

    void Initialize() override;
@@ -49,7 +45,7 @@ enum class PhotoViewerAppletMode : u8 {

 class PhotoViewer final : public Applet {
 public:
-    explicit PhotoViewer(Core::System& system_, const Core::Frontend::PhotoViewerApplet& frontend_);
+    explicit PhotoViewer(const Core::Frontend::PhotoViewerApplet& frontend);
    ~PhotoViewer() override;

    void Initialize() override;
@@ -64,12 +60,11 @@ private:
    const Core::Frontend::PhotoViewerApplet& frontend;
    bool complete = false;
    PhotoViewerAppletMode mode = PhotoViewerAppletMode::CurrentApp;
-    Core::System& system;
 };

 class StubApplet final : public Applet {
 public:
-    explicit StubApplet(Core::System& system_, AppletId id_);
+    explicit StubApplet(AppletId id);
    ~StubApplet() override;

    void Initialize() override;
@@ -81,7 +76,6 @@ public:

 private:
    AppletId id;
-    Core::System& system;
 };

 } // namespace Service::AM::Applets
@@ -15,9 +15,8 @@ namespace Service::AM::Applets {

 constexpr ResultCode ERR_USER_CANCELLED_SELECTION{ErrorModule::Account, 1};

-ProfileSelect::ProfileSelect(Core::System& system_,
-                             const Core::Frontend::ProfileSelectApplet& frontend_)
-    : Applet{system_.Kernel()}, frontend(frontend_) {}
+ProfileSelect::ProfileSelect(const Core::Frontend::ProfileSelectApplet& frontend)
+    : frontend(frontend) {}

 ProfileSelect::~ProfileSelect() = default;

@@ -11,10 +11,6 @@
 #include "core/hle/result.h"
 #include "core/hle/service/am/applets/applets.h"

-namespace Core {
-class System;
-}
-
 namespace Service::AM::Applets {

 struct UserSelectionConfig {
@@ -33,8 +29,7 @@ static_assert(sizeof(UserSelectionOutput) == 0x18, "UserSelectionOutput has inco

 class ProfileSelect final : public Applet {
 public:
-    explicit ProfileSelect(Core::System& system_,
-                           const Core::Frontend::ProfileSelectApplet& frontend_);
+    explicit ProfileSelect(const Core::Frontend::ProfileSelectApplet& frontend);
    ~ProfileSelect() override;

    void Initialize() override;
@@ -39,9 +39,8 @@ static Core::Frontend::SoftwareKeyboardParameters ConvertToFrontendParameters(
    return params;
 }

-SoftwareKeyboard::SoftwareKeyboard(Core::System& system_,
-                                   const Core::Frontend::SoftwareKeyboardApplet& frontend_)
-    : Applet{system_.Kernel()}, frontend(frontend_) {}
+SoftwareKeyboard::SoftwareKeyboard(const Core::Frontend::SoftwareKeyboardApplet& frontend)
+    : frontend(frontend) {}

 SoftwareKeyboard::~SoftwareKeyboard() = default;

@@ -16,10 +16,6 @@

 union ResultCode;

-namespace Core {
-class System;
-}
-
 namespace Service::AM::Applets {

 enum class KeysetDisable : u32 {
@@ -59,8 +55,7 @@ static_assert(sizeof(KeyboardConfig) == 0x3E0, "KeyboardConfig has incorrect siz

 class SoftwareKeyboard final : public Applet {
 public:
-    explicit SoftwareKeyboard(Core::System& system_,
-                              const Core::Frontend::SoftwareKeyboardApplet& frontend_);
+    explicit SoftwareKeyboard(const Core::Frontend::SoftwareKeyboardApplet& frontend);
    ~SoftwareKeyboard() override;

    void Initialize() override;
@@ -190,9 +190,8 @@ std::map<WebArgTLVType, std::vector<u8>> GetWebArguments(const std::vector<u8>&
    return out;
 }

-FileSys::VirtualFile GetApplicationRomFS(const Core::System& system, u64 title_id,
-                                         FileSys::ContentRecordType type) {
-    const auto& installed{system.GetContentProvider()};
+FileSys::VirtualFile GetApplicationRomFS(u64 title_id, FileSys::ContentRecordType type) {
+    const auto& installed{Core::System::GetInstance().GetContentProvider()};
    const auto res = installed.GetEntry(title_id, type);

    if (res != nullptr) {
@@ -208,10 +207,10 @@ FileSys::VirtualFile GetApplicationRomFS(const Core::System& system, u64 title_i

 } // Anonymous namespace

-WebBrowser::WebBrowser(Core::System& system_, Core::Frontend::WebBrowserApplet& frontend_,
-                       Core::Frontend::ECommerceApplet* frontend_e_commerce_)
-    : Applet{system_.Kernel()}, frontend(frontend_),
-      frontend_e_commerce(frontend_e_commerce_), system{system_} {}
+WebBrowser::WebBrowser(Core::Frontend::WebBrowserApplet& frontend, u64 current_process_title_id,
+                       Core::Frontend::ECommerceApplet* frontend_e_commerce)
+    : frontend(frontend), frontend_e_commerce(frontend_e_commerce),
+      current_process_title_id(current_process_title_id) {}

 WebBrowser::~WebBrowser() = default;

@@ -267,7 +266,7 @@ void WebBrowser::UnpackRomFS() {
    ASSERT(offline_romfs != nullptr);
    const auto dir =
        FileSys::ExtractRomFS(offline_romfs, FileSys::RomFSExtractionType::SingleDiscard);
-    const auto& vfs{system.GetFilesystem()};
+    const auto& vfs{Core::System::GetInstance().GetFilesystem()};
    const auto temp_dir = vfs->CreateDirectory(temporary_dir, FileSys::Mode::ReadWrite);
    FileSys::VfsRawCopyD(dir, temp_dir);

@@ -471,10 +470,10 @@ void WebBrowser::InitializeOffline() {
    }

    if (title_id == 0) {
-        title_id = system.CurrentProcess()->GetTitleID();
+        title_id = current_process_title_id;
    }

-    offline_romfs = GetApplicationRomFS(system, title_id, type);
+    offline_romfs = GetApplicationRomFS(title_id, type);
    if (offline_romfs == nullptr) {
        status = ResultCode(-1);
        LOG_ERROR(Service_AM, "Failed to find offline data for request!");
@@ -9,10 +9,6 @@
 #include "core/hle/service/am/am.h"
 #include "core/hle/service/am/applets/applets.h"

-namespace Core {
-class System;
-}
-
 namespace Service::AM::Applets {

 enum class ShimKind : u32;
@@ -21,8 +17,8 @@ enum class WebArgTLVType : u16;

 class WebBrowser final : public Applet {
 public:
-    WebBrowser(Core::System& system_, Core::Frontend::WebBrowserApplet& frontend_,
-               Core::Frontend::ECommerceApplet* frontend_e_commerce_ = nullptr);
+    WebBrowser(Core::Frontend::WebBrowserApplet& frontend, u64 current_process_title_id,
+               Core::Frontend::ECommerceApplet* frontend_e_commerce = nullptr);

    ~WebBrowser() override;

@@ -63,6 +59,8 @@ private:
    bool unpacked = false;
    ResultCode status = RESULT_SUCCESS;

+    u64 current_process_title_id;
+
    ShimKind kind;
    std::map<WebArgTLVType, std::vector<u8>> args;

@@ -76,8 +74,6 @@ private:
    std::optional<u128> user_id;
    std::optional<bool> shop_full_display;
    std::string shop_extra_parameter;
-
-    Core::System& system;
 };

 } // namespace Service::AM::Applets
@@ -165,15 +165,15 @@ public:
        static const FunctionInfo functions[] = {
            {0, &IAudioDevice::ListAudioDeviceName, "ListAudioDeviceName"},
            {1, &IAudioDevice::SetAudioDeviceOutputVolume, "SetAudioDeviceOutputVolume"},
-            {2, &IAudioDevice::GetAudioDeviceOutputVolume, "GetAudioDeviceOutputVolume"},
+            {2, nullptr, "GetAudioDeviceOutputVolume"},
            {3, &IAudioDevice::GetActiveAudioDeviceName, "GetActiveAudioDeviceName"},
            {4, &IAudioDevice::QueryAudioDeviceSystemEvent, "QueryAudioDeviceSystemEvent"},
            {5, &IAudioDevice::GetActiveChannelCount, "GetActiveChannelCount"},
            {6, &IAudioDevice::ListAudioDeviceName, "ListAudioDeviceNameAuto"},
            {7, &IAudioDevice::SetAudioDeviceOutputVolume, "SetAudioDeviceOutputVolumeAuto"},
-            {8, &IAudioDevice::GetAudioDeviceOutputVolume, "GetAudioDeviceOutputVolumeAuto"},
+            {8, nullptr, "GetAudioDeviceOutputVolumeAuto"},
            {10, &IAudioDevice::GetActiveAudioDeviceName, "GetActiveAudioDeviceNameAuto"},
-            {11, &IAudioDevice::QueryAudioDeviceInputEvent, "QueryAudioDeviceInputEvent"},
+            {11, nullptr, "QueryAudioDeviceInputEvent"},
            {12, &IAudioDevice::QueryAudioDeviceOutputEvent, "QueryAudioDeviceOutputEvent"},
            {13, nullptr, "GetAudioSystemMasterVolumeSetting"},
        };
@@ -183,10 +183,6 @@ public:
        buffer_event = Kernel::WritableEvent::CreateEventPair(kernel, Kernel::ResetType::Automatic,
                                                              "IAudioOutBufferReleasedEvent");

-        // Should be similar to audio_output_device_switch_event
-        audio_input_device_switch_event = Kernel::WritableEvent::CreateEventPair(
-            kernel, Kernel::ResetType::Automatic, "IAudioDevice:AudioInputDeviceSwitchedEvent");
-
        // Should only be signalled when an audio output device has been changed, example: speaker
        // to headset
        audio_output_device_switch_event = Kernel::WritableEvent::CreateEventPair(
@@ -250,19 +246,6 @@ private:
        rb.Push(RESULT_SUCCESS);
    }

-    void GetAudioDeviceOutputVolume(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-
-        const auto device_name_buffer = ctx.ReadBuffer();
-        const std::string name = Common::StringFromBuffer(device_name_buffer);
-
-        LOG_WARNING(Service_Audio, "(STUBBED) called. name={}", name);
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push(1.0f);
-    }
-
    void GetActiveAudioDeviceName(Kernel::HLERequestContext& ctx) {
        LOG_WARNING(Service_Audio, "(STUBBED) called");

@@ -296,15 +279,6 @@ private:
        rb.Push<u32>(1);
    }

-    // Should be similar to QueryAudioDeviceOutputEvent
-    void QueryAudioDeviceInputEvent(Kernel::HLERequestContext& ctx) {
-        LOG_WARNING(Service_Audio, "(STUBBED) called");
-
-        IPC::ResponseBuilder rb{ctx, 2, 1};
-        rb.Push(RESULT_SUCCESS);
-        rb.PushCopyObjects(audio_input_device_switch_event.readable);
-    }
-
    void QueryAudioDeviceOutputEvent(Kernel::HLERequestContext& ctx) {
        LOG_DEBUG(Service_Audio, "called");

@@ -315,7 +289,6 @@ private:

    u32_le revision = 0;
    Kernel::EventPair buffer_event;
-    Kernel::EventPair audio_input_device_switch_event;
    Kernel::EventPair audio_output_device_switch_event;

 }; // namespace Audio
@@ -2,37 +2,32 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-#include "core/crypto/key_manager.h"
-#include "core/hle/ipc_helpers.h"
 #include "core/hle/service/service.h"

 namespace Service::ES {

-constexpr ResultCode ERROR_INVALID_ARGUMENT{ErrorModule::ETicket, 2};
-constexpr ResultCode ERROR_INVALID_RIGHTS_ID{ErrorModule::ETicket, 3};
-
 class ETicket final : public ServiceFramework<ETicket> {
 public:
    explicit ETicket() : ServiceFramework{"es"} {
        // clang-format off
        static const FunctionInfo functions[] = {
-            {1, &ETicket::ImportTicket, "ImportTicket"},
+            {1, nullptr, "ImportTicket"},
            {2, nullptr, "ImportTicketCertificateSet"},
            {3, nullptr, "DeleteTicket"},
            {4, nullptr, "DeletePersonalizedTicket"},
            {5, nullptr, "DeleteAllCommonTicket"},
            {6, nullptr, "DeleteAllPersonalizedTicket"},
            {7, nullptr, "DeleteAllPersonalizedTicketEx"},
-            {8, &ETicket::GetTitleKey, "GetTitleKey"},
-            {9, &ETicket::CountCommonTicket, "CountCommonTicket"},
-            {10, &ETicket::CountPersonalizedTicket, "CountPersonalizedTicket"},
-            {11, &ETicket::ListCommonTicket, "ListCommonTicket"},
-            {12, &ETicket::ListPersonalizedTicket, "ListPersonalizedTicket"},
+            {8, nullptr, "GetTitleKey"},
+            {9, nullptr, "CountCommonTicket"},
+            {10, nullptr, "CountPersonalizedTicket"},
+            {11, nullptr, "ListCommonTicket"},
+            {12, nullptr, "ListPersonalizedTicket"},
            {13, nullptr, "ListMissingPersonalizedTicket"},
-            {14, &ETicket::GetCommonTicketSize, "GetCommonTicketSize"},
-            {15, &ETicket::GetPersonalizedTicketSize, "GetPersonalizedTicketSize"},
-            {16, &ETicket::GetCommonTicketData, "GetCommonTicketData"},
-            {17, &ETicket::GetPersonalizedTicketData, "GetPersonalizedTicketData"},
+            {14, nullptr, "GetCommonTicketSize"},
+            {15, nullptr, "GetPersonalizedTicketSize"},
+            {16, nullptr, "GetCommonTicketData"},
+            {17, nullptr, "GetPersonalizedTicketData"},
            {18, nullptr, "OwnTicket"},
            {19, nullptr, "GetTicketInfo"},
            {20, nullptr, "ListLightTicketInfo"},
@@ -56,212 +51,7 @@ public:
        };
        // clang-format on
        RegisterHandlers(functions);
-
-        keys.PopulateTickets();
-        keys.SynthesizeTickets();
    }
-
-private:
-    bool CheckRightsId(Kernel::HLERequestContext& ctx, const u128& rights_id) {
-        if (rights_id == u128{}) {
-            LOG_ERROR(Service_ETicket, "The rights ID was invalid!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_INVALID_RIGHTS_ID);
-            return false;
-        }
-
-        return true;
-    }
-
-    void ImportTicket(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto ticket = ctx.ReadBuffer();
-        const auto cert = ctx.ReadBuffer(1);
-
-        if (ticket.size() < sizeof(Core::Crypto::Ticket)) {
-            LOG_ERROR(Service_ETicket, "The input buffer is not large enough!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_INVALID_ARGUMENT);
-            return;
-        }
-
-        Core::Crypto::Ticket raw{};
-        std::memcpy(&raw, ticket.data(), sizeof(Core::Crypto::Ticket));
-
-        if (!keys.AddTicketPersonalized(raw)) {
-            LOG_ERROR(Service_ETicket, "The ticket could not be imported!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_INVALID_ARGUMENT);
-            return;
-        }
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void GetTitleKey(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto rights_id = rp.PopRaw<u128>();
-
-        LOG_DEBUG(Service_ETicket, "called, rights_id={:016X}{:016X}", rights_id[1], rights_id[0]);
-
-        if (!CheckRightsId(ctx, rights_id))
-            return;
-
-        const auto key =
-            keys.GetKey(Core::Crypto::S128KeyType::Titlekey, rights_id[1], rights_id[0]);
-
-        if (key == Core::Crypto::Key128{}) {
-            LOG_ERROR(Service_ETicket,
-                      "The titlekey doesn't exist in the KeyManager or the rights ID was invalid!");
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_INVALID_RIGHTS_ID);
-            return;
-        }
-
-        ctx.WriteBuffer(key.data(), key.size());
-
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(RESULT_SUCCESS);
-    }
-
-    void CountCommonTicket(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_ETicket, "called");
-
-        const auto count = keys.GetCommonTickets().size();
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(count);
-    }
-
-    void CountPersonalizedTicket(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_ETicket, "called");
-
-        const auto count = keys.GetPersonalizedTickets().size();
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(count);
-    }
-
-    void ListCommonTicket(Kernel::HLERequestContext& ctx) {
-        u32 out_entries;
-        if (keys.GetCommonTickets().empty())
-            out_entries = 0;
-        else
-            out_entries = ctx.GetWriteBufferSize() / sizeof(u128);
-
-        LOG_DEBUG(Service_ETicket, "called, entries={:016X}", out_entries);
-
-        keys.PopulateTickets();
-        const auto tickets = keys.GetCommonTickets();
-        std::vector<u128> ids;
-        std::transform(tickets.begin(), tickets.end(), std::back_inserter(ids),
-                       [](const auto& pair) { return pair.first; });
-
-        out_entries = std::min<u32>(ids.size(), out_entries);
-        ctx.WriteBuffer(ids.data(), out_entries * sizeof(u128));
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(out_entries);
-    }
-
-    void ListPersonalizedTicket(Kernel::HLERequestContext& ctx) {
-        u32 out_entries;
-        if (keys.GetPersonalizedTickets().empty())
-            out_entries = 0;
-        else
-            out_entries = ctx.GetWriteBufferSize() / sizeof(u128);
-
-        LOG_DEBUG(Service_ETicket, "called, entries={:016X}", out_entries);
-
-        keys.PopulateTickets();
-        const auto tickets = keys.GetPersonalizedTickets();
-        std::vector<u128> ids;
-        std::transform(tickets.begin(), tickets.end(), std::back_inserter(ids),
-                       [](const auto& pair) { return pair.first; });
-
-        out_entries = std::min<u32>(ids.size(), out_entries);
-        ctx.WriteBuffer(ids.data(), out_entries * sizeof(u128));
-
-        IPC::ResponseBuilder rb{ctx, 3};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u32>(out_entries);
-    }
-
-    void GetCommonTicketSize(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto rights_id = rp.PopRaw<u128>();
-
-        LOG_DEBUG(Service_ETicket, "called, rights_id={:016X}{:016X}", rights_id[1], rights_id[0]);
-
-        if (!CheckRightsId(ctx, rights_id))
-            return;
-
-        const auto ticket = keys.GetCommonTickets().at(rights_id);
-
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u64>(ticket.GetSize());
-    }
-
-    void GetPersonalizedTicketSize(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto rights_id = rp.PopRaw<u128>();
-
-        LOG_DEBUG(Service_ETicket, "called, rights_id={:016X}{:016X}", rights_id[1], rights_id[0]);
-
-        if (!CheckRightsId(ctx, rights_id))
-            return;
-
-        const auto ticket = keys.GetPersonalizedTickets().at(rights_id);
-
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u64>(ticket.GetSize());
-    }
-
-    void GetCommonTicketData(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto rights_id = rp.PopRaw<u128>();
-
-        LOG_DEBUG(Service_ETicket, "called, rights_id={:016X}{:016X}", rights_id[1], rights_id[0]);
-
-        if (!CheckRightsId(ctx, rights_id))
-            return;
-
-        const auto ticket = keys.GetCommonTickets().at(rights_id);
-
-        const auto write_size = std::min<u64>(ticket.GetSize(), ctx.GetWriteBufferSize());
-        ctx.WriteBuffer(&ticket, write_size);
-
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u64>(write_size);
-    }
-
-    void GetPersonalizedTicketData(Kernel::HLERequestContext& ctx) {
-        IPC::RequestParser rp{ctx};
-        const auto rights_id = rp.PopRaw<u128>();
-
-        LOG_DEBUG(Service_ETicket, "called, rights_id={:016X}{:016X}", rights_id[1], rights_id[0]);
-
-        if (!CheckRightsId(ctx, rights_id))
-            return;
-
-        const auto ticket = keys.GetPersonalizedTickets().at(rights_id);
-
-        const auto write_size = std::min<u64>(ticket.GetSize(), ctx.GetWriteBufferSize());
-        ctx.WriteBuffer(&ticket, write_size);
-
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(RESULT_SUCCESS);
-        rb.Push<u64>(write_size);
-    }
-
-    Core::Crypto::KeyManager keys;
 };

 void InstallInterfaces(SM::ServiceManager& service_manager) {
@@ -5,7 +5,7 @@
 #include <array>
 #include <cstring>
 #include <ctime>
-#include <fmt/chrono.h>
+#include <fmt/time.h>
 #include "common/file_util.h"
 #include "common/logging/log.h"
 #include "common/scm_rev.h"
@@ -636,15 +636,10 @@ Controller_NPad::LedPattern Controller_NPad::GetLedPattern(u32 npad_id) {
        return LedPattern{0, 0, 0, 0};
    };
 }
-
 void Controller_NPad::SetVibrationEnabled(bool can_vibrate) {
    can_controllers_vibrate = can_vibrate;
 }

-bool Controller_NPad::IsVibrationEnabled() const {
-    return can_controllers_vibrate;
-}
-
 void Controller_NPad::ClearAllConnectedControllers() {
    for (auto& controller : connected_controllers) {
        if (controller.is_connected && controller.type != NPadControllerType::None) {
@@ -653,7 +648,6 @@ void Controller_NPad::ClearAllConnectedControllers() {
        }
    }
 }
-
 void Controller_NPad::DisconnectAllConnectedControllers() {
    std::for_each(connected_controllers.begin(), connected_controllers.end(),
                  [](ControllerHolder& controller) { controller.is_connected = false; });
@@ -119,7 +119,6 @@ public:
    void DisconnectNPad(u32 npad_id);
    LedPattern GetLedPattern(u32 npad_id);
    void SetVibrationEnabled(bool can_vibrate);
-    bool IsVibrationEnabled() const;
    void ClearAllConnectedControllers();
    void DisconnectAllConnectedControllers();
    void ConnectAllDisconnectedControllers();
@@ -216,8 +216,8 @@ Hid::Hid() : ServiceFramework("hid") {
        {201, &Hid::SendVibrationValue, "SendVibrationValue"},
        {202, &Hid::GetActualVibrationValue, "GetActualVibrationValue"},
        {203, &Hid::CreateActiveVibrationDeviceList, "CreateActiveVibrationDeviceList"},
-        {204, &Hid::PermitVibration, "PermitVibration"},
-        {205, &Hid::IsVibrationPermitted, "IsVibrationPermitted"},
+        {204, nullptr, "PermitVibration"},
+        {205, nullptr, "IsVibrationPermitted"},
        {206, &Hid::SendVibrationValues, "SendVibrationValues"},
        {207, nullptr, "SendVibrationGcErmCommand"},
        {208, nullptr, "GetActualVibrationGcErmCommand"},
@@ -679,27 +679,6 @@ void Hid::CreateActiveVibrationDeviceList(Kernel::HLERequestContext& ctx) {
    rb.PushIpcInterface<IActiveVibrationDeviceList>();
 }

-void Hid::PermitVibration(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto can_vibrate{rp.Pop<bool>()};
-    applet_resource->GetController<Controller_NPad>(HidController::NPad)
-        .SetVibrationEnabled(can_vibrate);
-
-    LOG_DEBUG(Service_HID, "called, can_vibrate={}", can_vibrate);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(RESULT_SUCCESS);
-}
-
-void Hid::IsVibrationPermitted(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_HID, "called");
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(RESULT_SUCCESS);
-    rb.Push(
-        applet_resource->GetController<Controller_NPad>(HidController::NPad).IsVibrationEnabled());
-}
-
 void Hid::ActivateConsoleSixAxisSensor(Kernel::HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const auto applet_resource_user_id{rp.Pop<u64>()};
@@ -114,8 +114,6 @@ private:
    void SetNpadHandheldActivationMode(Kernel::HLERequestContext& ctx);
    void GetVibrationDeviceInfo(Kernel::HLERequestContext& ctx);
    void CreateActiveVibrationDeviceList(Kernel::HLERequestContext& ctx);
-    void PermitVibration(Kernel::HLERequestContext& ctx);
-    void IsVibrationPermitted(Kernel::HLERequestContext& ctx);
    void ActivateConsoleSixAxisSensor(Kernel::HLERequestContext& ctx);
    void StartConsoleSixAxisSensor(Kernel::HLERequestContext& ctx);
    void StopSixAxisSensor(Kernel::HLERequestContext& ctx);
@@ -175,10 +175,6 @@ MiiStoreData ConvertInfoToStoreData(const MiiInfo& info) {
 } // namespace

 std::ostream& operator<<(std::ostream& os, Source source) {
-    if (static_cast<std::size_t>(source) >= SOURCE_NAMES.size()) {
-        return os << "[UNKNOWN SOURCE]";
-    }
-
    os << SOURCE_NAMES.at(static_cast<std::size_t>(source));
    return os;
 }
@@ -37,7 +37,7 @@ void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u3
        transform, crop_rect};

    system.GetPerfStats().EndGameFrame();
-    system.GPU().SwapBuffers(&framebuffer);
+    system.GPU().SwapBuffers(framebuffer);
 }

 } // namespace Service::Nvidia::Devices
@@ -258,15 +258,6 @@ ResultStatus AppLoader_NRO::ReadTitle(std::string& title) {
    return ResultStatus::Success;
 }

-ResultStatus AppLoader_NRO::ReadControlData(FileSys::NACP& control) {
-    if (nacp == nullptr) {
-        return ResultStatus::ErrorNoControl;
-    }
-
-    control = *nacp;
-    return ResultStatus::Success;
-}
-
 bool AppLoader_NRO::IsRomFSUpdatable() const {
    return false;
 }
@@ -43,7 +43,6 @@ public:
    ResultStatus ReadProgramId(u64& out_program_id) override;
    ResultStatus ReadRomFS(FileSys::VirtualFile& dir) override;
    ResultStatus ReadTitle(std::string& title) override;
-    ResultStatus ReadControlData(FileSys::NACP& control) override;
    bool IsRomFSUpdatable() const override;

 private:
@@ -4,8 +4,14 @@

 #include <algorithm>
 #include <chrono>
+#include <iterator>
 #include <mutex>
+#include <numeric>
+#include <sstream>
 #include <thread>
+#include <fmt/format.h>
+#include <fmt/time.h>
+#include "common/file_util.h"
 #include "common/math_util.h"
 #include "core/perf_stats.h"
 #include "core/settings.h"
@@ -15,8 +21,31 @@ using DoubleSecs = std::chrono::duration<double, std::chrono::seconds::period>;
 using std::chrono::duration_cast;
 using std::chrono::microseconds;

+// Purposefully ignore the first five frames, as there's a significant amount of overhead in
+// booting that we shouldn't account for
+constexpr std::size_t IgnoreFrames = 5;
+
 namespace Core {

+PerfStats::PerfStats(u64 title_id) : title_id(title_id) {}
+
+PerfStats::~PerfStats() {
+    if (!Settings::values.record_frame_times || title_id == 0) {
+        return;
+    }
+
+    std::time_t t = std::time(nullptr);
+    std::ostringstream stream;
+    std::copy(perf_history.begin() + IgnoreFrames, perf_history.begin() + current_index,
+              std::ostream_iterator<double>(stream, "\n"));
+    std::string path = FileUtil::GetUserPath(FileUtil::UserPath::LogDir);
+    // %F Date format expanded is "%Y-%m-%d"
+    std::string filename =
+        fmt::format("{}/{:%F-%H-%M}_{:016X}.csv", path, *std::localtime(&t), title_id);
+    FileUtil::IOFile file(filename, "w");
+    file.WriteString(stream.str());
+}
+
 void PerfStats::BeginSystemFrame() {
    std::lock_guard lock{object_mutex};

@@ -27,7 +56,12 @@ void PerfStats::EndSystemFrame() {
    std::lock_guard lock{object_mutex};

    auto frame_end = Clock::now();
-    accumulated_frametime += frame_end - frame_begin;
+    const auto frame_time = frame_end - frame_begin;
+    if (current_index < perf_history.size()) {
+        perf_history[current_index++] =
+            std::chrono::duration<double, std::milli>(frame_time).count();
+    }
+    accumulated_frametime += frame_time;
    system_frames += 1;

    previous_frame_length = frame_end - previous_frame_end;
@@ -40,6 +74,15 @@ void PerfStats::EndGameFrame() {
    game_frames += 1;
 }

+double PerfStats::GetMeanFrametime() {
+    if (current_index <= IgnoreFrames) {
+        return 0;
+    }
+    double sum = std::accumulate(perf_history.begin() + IgnoreFrames,
+                                 perf_history.begin() + current_index, 0);
+    return sum / (current_index - IgnoreFrames);
+}
+
 PerfStatsResults PerfStats::GetAndResetStats(microseconds current_system_time_us) {
    std::lock_guard lock{object_mutex};

@@ -4,6 +4,7 @@

 #pragma once

+#include <array>
 #include <chrono>
 #include <mutex>
 #include "common/common_types.h"
@@ -27,6 +28,10 @@ struct PerfStatsResults {
 */
 class PerfStats {
 public:
+    explicit PerfStats(u64 title_id);
+
+    ~PerfStats();
+
    using Clock = std::chrono::high_resolution_clock;

    void BeginSystemFrame();
@@ -35,6 +40,11 @@ public:

    PerfStatsResults GetAndResetStats(std::chrono::microseconds current_system_time_us);

+    /**
+     * Returns the Arthimetic Mean of all frametime values stored in the performance history.
+     */
+    double GetMeanFrametime();
+
    /**
     * Gets the ratio between walltime and the emulated time of the previous system frame. This is
     * useful for scaling inputs or outputs moving between the two time domains.
@@ -42,7 +52,15 @@ public:
    double GetLastFrameTimeScale();

 private:
-    std::mutex object_mutex;
+    std::mutex object_mutex{};
+
+    /// Title ID for the game that is running. 0 if there is no game running yet
+    u64 title_id{0};
+    /// Current index for writing to the perf_history array
+    std::size_t current_index{0};
+    /// Stores an hour of historical frametime data useful for processing and tracking performance
+    /// regressions with code changes.
+    std::array<double, 216000> perf_history = {};

    /// Point when the cumulative counters were reset
    Clock::time_point reset_point = Clock::now();
@@ -5,8 +5,8 @@
 #include <ctime>
 #include <fstream>

-#include <fmt/chrono.h>
 #include <fmt/format.h>
+#include <fmt/time.h>
 #include <json.hpp>

 #include "common/file_util.h"
@@ -409,6 +409,7 @@ struct Values {
    float volume;

    // Debugging
+    bool record_frame_times;
    bool use_gdbstub;
    u16 gdbstub_port;
    std::string program_args;
@@ -1,7 +1,5 @@
 add_library(video_core STATIC
-    buffer_cache/buffer_block.h
-    buffer_cache/buffer_cache.h
-    buffer_cache/map_interval.h
+    buffer_cache.h
    dma_pusher.cpp
    dma_pusher.h
    debug_utils/debug_utils.cpp
@@ -102,7 +100,6 @@ add_library(video_core STATIC
    shader/decode/integer_set.cpp
    shader/decode/half_set.cpp
    shader/decode/video.cpp
-    shader/decode/warp.cpp
    shader/decode/xmad.cpp
    shader/decode/other.cpp
    shader/control_flow.cpp
@@ -0,0 +1,299 @@
+// Copyright 2019 yuzu Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <array>
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "common/alignment.h"
+#include "common/common_types.h"
+#include "core/core.h"
+#include "video_core/memory_manager.h"
+#include "video_core/rasterizer_cache.h"
+
+namespace VideoCore {
+class RasterizerInterface;
+}
+
+namespace VideoCommon {
+
+template <typename BufferStorageType>
+class CachedBuffer final : public RasterizerCacheObject {
+public:
+    explicit CachedBuffer(VAddr cpu_addr, u8* host_ptr)
+        : RasterizerCacheObject{host_ptr}, host_ptr{host_ptr}, cpu_addr{cpu_addr} {}
+    ~CachedBuffer() override = default;
+
+    VAddr GetCpuAddr() const override {
+        return cpu_addr;
+    }
+
+    std::size_t GetSizeInBytes() const override {
+        return size;
+    }
+
+    u8* GetWritableHostPtr() const {
+        return host_ptr;
+    }
+
+    std::size_t GetSize() const {
+        return size;
+    }
+
+    std::size_t GetCapacity() const {
+        return capacity;
+    }
+
+    bool IsInternalized() const {
+        return is_internal;
+    }
+
+    const BufferStorageType& GetBuffer() const {
+        return buffer;
+    }
+
+    void SetSize(std::size_t new_size) {
+        size = new_size;
+    }
+
+    void SetInternalState(bool is_internal_) {
+        is_internal = is_internal_;
+    }
+
+    BufferStorageType ExchangeBuffer(BufferStorageType buffer_, std::size_t new_capacity) {
+        capacity = new_capacity;
+        std::swap(buffer, buffer_);
+        return buffer_;
+    }
+
+private:
+    u8* host_ptr{};
+    VAddr cpu_addr{};
+    std::size_t size{};
+    std::size_t capacity{};
+    bool is_internal{};
+    BufferStorageType buffer;
+};
+
+template <typename BufferStorageType, typename BufferType, typename StreamBuffer>
+class BufferCache : public RasterizerCache<std::shared_ptr<CachedBuffer<BufferStorageType>>> {
+public:
+    using Buffer = std::shared_ptr<CachedBuffer<BufferStorageType>>;
+    using BufferInfo = std::pair<const BufferType*, u64>;
+
+    explicit BufferCache(VideoCore::RasterizerInterface& rasterizer, Core::System& system,
+                         std::unique_ptr<StreamBuffer> stream_buffer)
+        : RasterizerCache<Buffer>{rasterizer}, system{system},
+          stream_buffer{std::move(stream_buffer)}, stream_buffer_handle{
+                                                       this->stream_buffer->GetHandle()} {}
+    ~BufferCache() = default;
+
+    void Unregister(const Buffer& entry) override {
+        std::lock_guard lock{RasterizerCache<Buffer>::mutex};
+        if (entry->IsInternalized()) {
+            internalized_entries.erase(entry->GetCacheAddr());
+        }
+        ReserveBuffer(entry);
+        RasterizerCache<Buffer>::Unregister(entry);
+    }
+
+    void TickFrame() {
+        marked_for_destruction_index =
+            (marked_for_destruction_index + 1) % marked_for_destruction_ring_buffer.size();
+        MarkedForDestruction().clear();
+    }
+
+    BufferInfo UploadMemory(GPUVAddr gpu_addr, std::size_t size, std::size_t alignment = 4,
+                            bool internalize = false, bool is_written = false) {
+        std::lock_guard lock{RasterizerCache<Buffer>::mutex};
+
+        auto& memory_manager = system.GPU().MemoryManager();
+        const auto host_ptr = memory_manager.GetPointer(gpu_addr);
+        if (!host_ptr) {
+            return {GetEmptyBuffer(size), 0};
+        }
+        const auto cache_addr = ToCacheAddr(host_ptr);
+
+        // Cache management is a big overhead, so only cache entries with a given size.
+        // TODO: Figure out which size is the best for given games.
+        constexpr std::size_t max_stream_size = 0x800;
+        if (!internalize && size < max_stream_size &&
+            internalized_entries.find(cache_addr) == internalized_entries.end()) {
+            return StreamBufferUpload(host_ptr, size, alignment);
+        }
+
+        auto entry = RasterizerCache<Buffer>::TryGet(cache_addr);
+        if (!entry) {
+            return FixedBufferUpload(gpu_addr, host_ptr, size, internalize, is_written);
+        }
+
+        if (entry->GetSize() < size) {
+            IncreaseBufferSize(entry, size);
+        }
+        if (is_written) {
+            entry->MarkAsModified(true, *this);
+        }
+        return {ToHandle(entry->GetBuffer()), 0};
+    }
+
+    /// Uploads from a host memory. Returns the OpenGL buffer where it's located and its offset.
+    BufferInfo UploadHostMemory(const void* raw_pointer, std::size_t size,
+                                std::size_t alignment = 4) {
+        std::lock_guard lock{RasterizerCache<Buffer>::mutex};
+        return StreamBufferUpload(raw_pointer, size, alignment);
+    }
+
+    void Map(std::size_t max_size) {
+        std::tie(buffer_ptr, buffer_offset_base, invalidated) = stream_buffer->Map(max_size, 4);
+        buffer_offset = buffer_offset_base;
+    }
+
+    /// Finishes the upload stream, returns true on bindings invalidation.
+    bool Unmap() {
+        stream_buffer->Unmap(buffer_offset - buffer_offset_base);
+        return std::exchange(invalidated, false);
+    }
+
+    virtual const BufferType* GetEmptyBuffer(std::size_t size) = 0;
+
+protected:
+    void FlushObjectInner(const Buffer& entry) override {
+        DownloadBufferData(entry->GetBuffer(), 0, entry->GetSize(), entry->GetWritableHostPtr());
+    }
+
+    virtual BufferStorageType CreateBuffer(std::size_t size) = 0;
+
+    virtual const BufferType* ToHandle(const BufferStorageType& storage) = 0;
+
+    virtual void UploadBufferData(const BufferStorageType& buffer, std::size_t offset,
+                                  std::size_t size, const u8* data) = 0;
+
+    virtual void DownloadBufferData(const BufferStorageType& buffer, std::size_t offset,
+                                    std::size_t size, u8* data) = 0;
+
+    virtual void CopyBufferData(const BufferStorageType& src, const BufferStorageType& dst,
+                                std::size_t src_offset, std::size_t dst_offset,
+                                std::size_t size) = 0;
+
+private:
+    BufferInfo StreamBufferUpload(const void* raw_pointer, std::size_t size,
+                                  std::size_t alignment) {
+        AlignBuffer(alignment);
+        const std::size_t uploaded_offset = buffer_offset;
+        std::memcpy(buffer_ptr, raw_pointer, size);
+
+        buffer_ptr += size;
+        buffer_offset += size;
+        return {&stream_buffer_handle, uploaded_offset};
+    }
+
+    BufferInfo FixedBufferUpload(GPUVAddr gpu_addr, u8* host_ptr, std::size_t size,
+                                 bool internalize, bool is_written) {
+        auto& memory_manager = Core::System::GetInstance().GPU().MemoryManager();
+        const auto cpu_addr = memory_manager.GpuToCpuAddress(gpu_addr);
+        ASSERT(cpu_addr);
+
+        auto entry = GetUncachedBuffer(*cpu_addr, host_ptr);
+        entry->SetSize(size);
+        entry->SetInternalState(internalize);
+        RasterizerCache<Buffer>::Register(entry);
+
+        if (internalize) {
+            internalized_entries.emplace(ToCacheAddr(host_ptr));
+        }
+        if (is_written) {
+            entry->MarkAsModified(true, *this);
+        }
+
+        if (entry->GetCapacity() < size) {
+            MarkedForDestruction().push_back(entry->ExchangeBuffer(CreateBuffer(size), size));
+        }
+
+        UploadBufferData(entry->GetBuffer(), 0, size, host_ptr);
+        return {ToHandle(entry->GetBuffer()), 0};
+    }
+
+    void IncreaseBufferSize(Buffer& entry, std::size_t new_size) {
+        const std::size_t old_size = entry->GetSize();
+        if (entry->GetCapacity() < new_size) {
+            const auto& old_buffer = entry->GetBuffer();
+            auto new_buffer = CreateBuffer(new_size);
+
+            // Copy bits from the old buffer to the new buffer.
+            CopyBufferData(old_buffer, new_buffer, 0, 0, old_size);
+            MarkedForDestruction().push_back(
+                entry->ExchangeBuffer(std::move(new_buffer), new_size));
+
+            // This buffer could have been used
+            invalidated = true;
+        }
+        // Upload the new bits.
+        const std::size_t size_diff = new_size - old_size;
+        UploadBufferData(entry->GetBuffer(), old_size, size_diff, entry->GetHostPtr() + old_size);
+
+        // Update entry's size in the object and in the cache.
+        Unregister(entry);
+
+        entry->SetSize(new_size);
+        RasterizerCache<Buffer>::Register(entry);
+    }
+
+    Buffer GetUncachedBuffer(VAddr cpu_addr, u8* host_ptr) {
+        if (auto entry = TryGetReservedBuffer(host_ptr)) {
+            return entry;
+        }
+        return std::make_shared<CachedBuffer<BufferStorageType>>(cpu_addr, host_ptr);
+    }
+
+    Buffer TryGetReservedBuffer(u8* host_ptr) {
+        const auto it = buffer_reserve.find(ToCacheAddr(host_ptr));
+        if (it == buffer_reserve.end()) {
+            return {};
+        }
+        auto& reserve = it->second;
+        auto entry = reserve.back();
+        reserve.pop_back();
+        return entry;
+    }
+
+    void ReserveBuffer(Buffer entry) {
+        buffer_reserve[entry->GetCacheAddr()].push_back(std::move(entry));
+    }
+
+    void AlignBuffer(std::size_t alignment) {
+        // Align the offset, not the mapped pointer
+        const std::size_t offset_aligned = Common::AlignUp(buffer_offset, alignment);
+        buffer_ptr += offset_aligned - buffer_offset;
+        buffer_offset = offset_aligned;
+    }
+
+    std::vector<BufferStorageType>& MarkedForDestruction() {
+        return marked_for_destruction_ring_buffer[marked_for_destruction_index];
+    }
+
+    Core::System& system;
+
+    std::unique_ptr<StreamBuffer> stream_buffer;
+    BufferType stream_buffer_handle{};
+
+    bool invalidated = false;
+
+    u8* buffer_ptr = nullptr;
+    u64 buffer_offset = 0;
+    u64 buffer_offset_base = 0;
+
+    std::size_t marked_for_destruction_index = 0;
+    std::array<std::vector<BufferStorageType>, 4> marked_for_destruction_ring_buffer;
+
+    std::unordered_set<CacheAddr> internalized_entries;
+    std::unordered_map<CacheAddr, std::vector<Buffer>> buffer_reserve;
+};
+
+} // namespace VideoCommon
@@ -1,76 +0,0 @@
-// Copyright 2019 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <unordered_set>
-#include <utility>
-
-#include "common/alignment.h"
-#include "common/common_types.h"
-#include "video_core/gpu.h"
-
-namespace VideoCommon {
-
-class BufferBlock {
-public:
-    bool Overlaps(const CacheAddr start, const CacheAddr end) const {
-        return (cache_addr < end) && (cache_addr_end > start);
-    }
-
-    bool IsInside(const CacheAddr other_start, const CacheAddr other_end) const {
-        return cache_addr <= other_start && other_end <= cache_addr_end;
-    }
-
-    u8* GetWritableHostPtr() const {
-        return FromCacheAddr(cache_addr);
-    }
-
-    u8* GetWritableHostPtr(std::size_t offset) const {
-        return FromCacheAddr(cache_addr + offset);
-    }
-
-    std::size_t GetOffset(const CacheAddr in_addr) {
-        return static_cast<std::size_t>(in_addr - cache_addr);
-    }
-
-    CacheAddr GetCacheAddr() const {
-        return cache_addr;
-    }
-
-    CacheAddr GetCacheAddrEnd() const {
-        return cache_addr_end;
-    }
-
-    void SetCacheAddr(const CacheAddr new_addr) {
-        cache_addr = new_addr;
-        cache_addr_end = new_addr + size;
-    }
-
-    std::size_t GetSize() const {
-        return size;
-    }
-
-    void SetEpoch(u64 new_epoch) {
-        epoch = new_epoch;
-    }
-
-    u64 GetEpoch() {
-        return epoch;
-    }
-
-protected:
-    explicit BufferBlock(CacheAddr cache_addr, const std::size_t size) : size{size} {
-        SetCacheAddr(cache_addr);
-    }
-    ~BufferBlock() = default;
-
-private:
-    CacheAddr cache_addr{};
-    CacheAddr cache_addr_end{};
-    std::size_t size{};
-    u64 epoch{};
-};
-
-} // namespace VideoCommon
@@ -1,447 +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 <memory>
-#include <mutex>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <vector>
-
-#include "common/alignment.h"
-#include "common/common_types.h"
-#include "core/core.h"
-#include "video_core/buffer_cache/buffer_block.h"
-#include "video_core/buffer_cache/map_interval.h"
-#include "video_core/memory_manager.h"
-#include "video_core/rasterizer_interface.h"
-
-namespace VideoCommon {
-
-using MapInterval = std::shared_ptr<MapIntervalBase>;
-
-template <typename TBuffer, typename TBufferType, typename StreamBuffer>
-class BufferCache {
-public:
-    using BufferInfo = std::pair<const TBufferType*, u64>;
-
-    BufferInfo UploadMemory(GPUVAddr gpu_addr, std::size_t size, std::size_t alignment = 4,
-                            bool is_written = false) {
-        std::lock_guard lock{mutex};
-
-        auto& memory_manager = system.GPU().MemoryManager();
-        const auto host_ptr = memory_manager.GetPointer(gpu_addr);
-        if (!host_ptr) {
-            return {GetEmptyBuffer(size), 0};
-        }
-        const auto cache_addr = ToCacheAddr(host_ptr);
-
-        // Cache management is a big overhead, so only cache entries with a given size.
-        // TODO: Figure out which size is the best for given games.
-        constexpr std::size_t max_stream_size = 0x800;
-        if (size < max_stream_size) {
-            if (!is_written && !IsRegionWritten(cache_addr, cache_addr + size - 1)) {
-                return StreamBufferUpload(host_ptr, size, alignment);
-            }
-        }
-
-        auto block = GetBlock(cache_addr, size);
-        auto map = MapAddress(block, gpu_addr, cache_addr, size);
-        if (is_written) {
-            map->MarkAsModified(true, GetModifiedTicks());
-            if (!map->IsWritten()) {
-                map->MarkAsWritten(true);
-                MarkRegionAsWritten(map->GetStart(), map->GetEnd() - 1);
-            }
-        } else {
-            if (map->IsWritten()) {
-                WriteBarrier();
-            }
-        }
-
-        const u64 offset = static_cast<u64>(block->GetOffset(cache_addr));
-
-        return {ToHandle(block), offset};
-    }
-
-    /// Uploads from a host memory. Returns the OpenGL buffer where it's located and its offset.
-    BufferInfo UploadHostMemory(const void* raw_pointer, std::size_t size,
-                                std::size_t alignment = 4) {
-        std::lock_guard lock{mutex};
-        return StreamBufferUpload(raw_pointer, size, alignment);
-    }
-
-    void Map(std::size_t max_size) {
-        std::lock_guard lock{mutex};
-
-        std::tie(buffer_ptr, buffer_offset_base, invalidated) = stream_buffer->Map(max_size, 4);
-        buffer_offset = buffer_offset_base;
-    }
-
-    /// Finishes the upload stream, returns true on bindings invalidation.
-    bool Unmap() {
-        std::lock_guard lock{mutex};
-
-        stream_buffer->Unmap(buffer_offset - buffer_offset_base);
-        return std::exchange(invalidated, false);
-    }
-
-    void TickFrame() {
-        ++epoch;
-        while (!pending_destruction.empty()) {
-            if (pending_destruction.front()->GetEpoch() + 1 > epoch) {
-                break;
-            }
-            pending_destruction.pop_front();
-        }
-    }
-
-    /// Write any cached resources overlapping the specified region back to memory
-    void FlushRegion(CacheAddr addr, std::size_t size) {
-        std::lock_guard lock{mutex};
-
-        std::vector<MapInterval> objects = GetMapsInRange(addr, size);
-        std::sort(objects.begin(), objects.end(), [](const MapInterval& a, const MapInterval& b) {
-            return a->GetModificationTick() < b->GetModificationTick();
-        });
-        for (auto& object : objects) {
-            if (object->IsModified() && object->IsRegistered()) {
-                FlushMap(object);
-            }
-        }
-    }
-
-    /// Mark the specified region as being invalidated
-    void InvalidateRegion(CacheAddr addr, u64 size) {
-        std::lock_guard lock{mutex};
-
-        std::vector<MapInterval> objects = GetMapsInRange(addr, size);
-        for (auto& object : objects) {
-            if (object->IsRegistered()) {
-                Unregister(object);
-            }
-        }
-    }
-
-    virtual const TBufferType* GetEmptyBuffer(std::size_t size) = 0;
-
-protected:
-    explicit BufferCache(VideoCore::RasterizerInterface& rasterizer, Core::System& system,
-                         std::unique_ptr<StreamBuffer> stream_buffer)
-        : rasterizer{rasterizer}, system{system}, stream_buffer{std::move(stream_buffer)},
-          stream_buffer_handle{this->stream_buffer->GetHandle()} {}
-
-    ~BufferCache() = default;
-
-    virtual const TBufferType* ToHandle(const TBuffer& storage) = 0;
-
-    virtual void WriteBarrier() = 0;
-
-    virtual TBuffer CreateBlock(CacheAddr cache_addr, std::size_t size) = 0;
-
-    virtual void UploadBlockData(const TBuffer& buffer, std::size_t offset, std::size_t size,
-                                 const u8* data) = 0;
-
-    virtual void DownloadBlockData(const TBuffer& buffer, std::size_t offset, std::size_t size,
-                                   u8* data) = 0;
-
-    virtual void CopyBlock(const TBuffer& src, const TBuffer& dst, std::size_t src_offset,
-                           std::size_t dst_offset, std::size_t size) = 0;
-
-    /// Register an object into the cache
-    void Register(const MapInterval& new_map, bool inherit_written = false) {
-        const CacheAddr cache_ptr = new_map->GetStart();
-        const std::optional<VAddr> cpu_addr =
-            system.GPU().MemoryManager().GpuToCpuAddress(new_map->GetGpuAddress());
-        if (!cache_ptr || !cpu_addr) {
-            LOG_CRITICAL(HW_GPU, "Failed to register buffer with unmapped gpu_address 0x{:016x}",
-                         new_map->GetGpuAddress());
-            return;
-        }
-        const std::size_t size = new_map->GetEnd() - new_map->GetStart();
-        new_map->SetCpuAddress(*cpu_addr);
-        new_map->MarkAsRegistered(true);
-        const IntervalType interval{new_map->GetStart(), new_map->GetEnd()};
-        mapped_addresses.insert({interval, new_map});
-        rasterizer.UpdatePagesCachedCount(*cpu_addr, size, 1);
-        if (inherit_written) {
-            MarkRegionAsWritten(new_map->GetStart(), new_map->GetEnd() - 1);
-            new_map->MarkAsWritten(true);
-        }
-    }
-
-    /// Unregisters an object from the cache
-    void Unregister(MapInterval& map) {
-        const std::size_t size = map->GetEnd() - map->GetStart();
-        rasterizer.UpdatePagesCachedCount(map->GetCpuAddress(), size, -1);
-        map->MarkAsRegistered(false);
-        if (map->IsWritten()) {
-            UnmarkRegionAsWritten(map->GetStart(), map->GetEnd() - 1);
-        }
-        const IntervalType delete_interval{map->GetStart(), map->GetEnd()};
-        mapped_addresses.erase(delete_interval);
-    }
-
-private:
-    MapInterval CreateMap(const CacheAddr start, const CacheAddr end, const GPUVAddr gpu_addr) {
-        return std::make_shared<MapIntervalBase>(start, end, gpu_addr);
-    }
-
-    MapInterval MapAddress(const TBuffer& block, const GPUVAddr gpu_addr,
-                           const CacheAddr cache_addr, const std::size_t size) {
-
-        std::vector<MapInterval> overlaps = GetMapsInRange(cache_addr, size);
-        if (overlaps.empty()) {
-            const CacheAddr cache_addr_end = cache_addr + size;
-            MapInterval new_map = CreateMap(cache_addr, cache_addr_end, gpu_addr);
-            u8* host_ptr = FromCacheAddr(cache_addr);
-            UploadBlockData(block, block->GetOffset(cache_addr), size, host_ptr);
-            Register(new_map);
-            return new_map;
-        }
-
-        const CacheAddr cache_addr_end = cache_addr + size;
-        if (overlaps.size() == 1) {
-            MapInterval& current_map = overlaps[0];
-            if (current_map->IsInside(cache_addr, cache_addr_end)) {
-                return current_map;
-            }
-        }
-        CacheAddr new_start = cache_addr;
-        CacheAddr new_end = cache_addr_end;
-        bool write_inheritance = false;
-        bool modified_inheritance = false;
-        // Calculate new buffer parameters
-        for (auto& overlap : overlaps) {
-            new_start = std::min(overlap->GetStart(), new_start);
-            new_end = std::max(overlap->GetEnd(), new_end);
-            write_inheritance |= overlap->IsWritten();
-            modified_inheritance |= overlap->IsModified();
-        }
-        GPUVAddr new_gpu_addr = gpu_addr + new_start - cache_addr;
-        for (auto& overlap : overlaps) {
-            Unregister(overlap);
-        }
-        UpdateBlock(block, new_start, new_end, overlaps);
-        MapInterval new_map = CreateMap(new_start, new_end, new_gpu_addr);
-        if (modified_inheritance) {
-            new_map->MarkAsModified(true, GetModifiedTicks());
-        }
-        Register(new_map, write_inheritance);
-        return new_map;
-    }
-
-    void UpdateBlock(const TBuffer& block, CacheAddr start, CacheAddr end,
-                     std::vector<MapInterval>& overlaps) {
-        const IntervalType base_interval{start, end};
-        IntervalSet interval_set{};
-        interval_set.add(base_interval);
-        for (auto& overlap : overlaps) {
-            const IntervalType subtract{overlap->GetStart(), overlap->GetEnd()};
-            interval_set.subtract(subtract);
-        }
-        for (auto& interval : interval_set) {
-            std::size_t size = interval.upper() - interval.lower();
-            if (size > 0) {
-                u8* host_ptr = FromCacheAddr(interval.lower());
-                UploadBlockData(block, block->GetOffset(interval.lower()), size, host_ptr);
-            }
-        }
-    }
-
-    std::vector<MapInterval> GetMapsInRange(CacheAddr addr, std::size_t size) {
-        if (size == 0) {
-            return {};
-        }
-
-        std::vector<MapInterval> objects{};
-        const IntervalType interval{addr, addr + size};
-        for (auto& pair : boost::make_iterator_range(mapped_addresses.equal_range(interval))) {
-            objects.push_back(pair.second);
-        }
-
-        return objects;
-    }
-
-    /// Returns a ticks counter used for tracking when cached objects were last modified
-    u64 GetModifiedTicks() {
-        return ++modified_ticks;
-    }
-
-    void FlushMap(MapInterval map) {
-        std::size_t size = map->GetEnd() - map->GetStart();
-        TBuffer block = blocks[map->GetStart() >> block_page_bits];
-        u8* host_ptr = FromCacheAddr(map->GetStart());
-        DownloadBlockData(block, block->GetOffset(map->GetStart()), size, host_ptr);
-        map->MarkAsModified(false, 0);
-    }
-
-    BufferInfo StreamBufferUpload(const void* raw_pointer, std::size_t size,
-                                  std::size_t alignment) {
-        AlignBuffer(alignment);
-        const std::size_t uploaded_offset = buffer_offset;
-        std::memcpy(buffer_ptr, raw_pointer, size);
-
-        buffer_ptr += size;
-        buffer_offset += size;
-        return {&stream_buffer_handle, uploaded_offset};
-    }
-
-    void AlignBuffer(std::size_t alignment) {
-        // Align the offset, not the mapped pointer
-        const std::size_t offset_aligned = Common::AlignUp(buffer_offset, alignment);
-        buffer_ptr += offset_aligned - buffer_offset;
-        buffer_offset = offset_aligned;
-    }
-
-    TBuffer EnlargeBlock(TBuffer buffer) {
-        const std::size_t old_size = buffer->GetSize();
-        const std::size_t new_size = old_size + block_page_size;
-        const CacheAddr cache_addr = buffer->GetCacheAddr();
-        TBuffer new_buffer = CreateBlock(cache_addr, new_size);
-        CopyBlock(buffer, new_buffer, 0, 0, old_size);
-        buffer->SetEpoch(epoch);
-        pending_destruction.push_back(buffer);
-        const CacheAddr cache_addr_end = cache_addr + new_size - 1;
-        u64 page_start = cache_addr >> block_page_bits;
-        const u64 page_end = cache_addr_end >> block_page_bits;
-        while (page_start <= page_end) {
-            blocks[page_start] = new_buffer;
-            ++page_start;
-        }
-        return new_buffer;
-    }
-
-    TBuffer MergeBlocks(TBuffer first, TBuffer second) {
-        const std::size_t size_1 = first->GetSize();
-        const std::size_t size_2 = second->GetSize();
-        const CacheAddr first_addr = first->GetCacheAddr();
-        const CacheAddr second_addr = second->GetCacheAddr();
-        const CacheAddr new_addr = std::min(first_addr, second_addr);
-        const std::size_t new_size = size_1 + size_2;
-        TBuffer new_buffer = CreateBlock(new_addr, new_size);
-        CopyBlock(first, new_buffer, 0, new_buffer->GetOffset(first_addr), size_1);
-        CopyBlock(second, new_buffer, 0, new_buffer->GetOffset(second_addr), size_2);
-        first->SetEpoch(epoch);
-        second->SetEpoch(epoch);
-        pending_destruction.push_back(first);
-        pending_destruction.push_back(second);
-        const CacheAddr cache_addr_end = new_addr + new_size - 1;
-        u64 page_start = new_addr >> block_page_bits;
-        const u64 page_end = cache_addr_end >> block_page_bits;
-        while (page_start <= page_end) {
-            blocks[page_start] = new_buffer;
-            ++page_start;
-        }
-        return new_buffer;
-    }
-
-    TBuffer GetBlock(const CacheAddr cache_addr, const std::size_t size) {
-        TBuffer found{};
-        const CacheAddr cache_addr_end = cache_addr + size - 1;
-        u64 page_start = cache_addr >> block_page_bits;
-        const u64 page_end = cache_addr_end >> block_page_bits;
-        while (page_start <= page_end) {
-            auto it = blocks.find(page_start);
-            if (it == blocks.end()) {
-                if (found) {
-                    found = EnlargeBlock(found);
-                } else {
-                    const CacheAddr start_addr = (page_start << block_page_bits);
-                    found = CreateBlock(start_addr, block_page_size);
-                    blocks[page_start] = found;
-                }
-            } else {
-                if (found) {
-                    if (found == it->second) {
-                        ++page_start;
-                        continue;
-                    }
-                    found = MergeBlocks(found, it->second);
-                } else {
-                    found = it->second;
-                }
-            }
-            ++page_start;
-        }
-        return found;
-    }
-
-    void MarkRegionAsWritten(const CacheAddr start, const CacheAddr end) {
-        u64 page_start = start >> write_page_bit;
-        const u64 page_end = end >> write_page_bit;
-        while (page_start <= page_end) {
-            auto it = written_pages.find(page_start);
-            if (it != written_pages.end()) {
-                it->second = it->second + 1;
-            } else {
-                written_pages[page_start] = 1;
-            }
-            page_start++;
-        }
-    }
-
-    void UnmarkRegionAsWritten(const CacheAddr start, const CacheAddr end) {
-        u64 page_start = start >> write_page_bit;
-        const u64 page_end = end >> write_page_bit;
-        while (page_start <= page_end) {
-            auto it = written_pages.find(page_start);
-            if (it != written_pages.end()) {
-                if (it->second > 1) {
-                    it->second = it->second - 1;
-                } else {
-                    written_pages.erase(it);
-                }
-            }
-            page_start++;
-        }
-    }
-
-    bool IsRegionWritten(const CacheAddr start, const CacheAddr end) const {
-        u64 page_start = start >> write_page_bit;
-        const u64 page_end = end >> write_page_bit;
-        while (page_start <= page_end) {
-            if (written_pages.count(page_start) > 0) {
-                return true;
-            }
-            page_start++;
-        }
-        return false;
-    }
-
-    VideoCore::RasterizerInterface& rasterizer;
-    Core::System& system;
-    std::unique_ptr<StreamBuffer> stream_buffer;
-
-    TBufferType stream_buffer_handle{};
-
-    bool invalidated = false;
-
-    u8* buffer_ptr = nullptr;
-    u64 buffer_offset = 0;
-    u64 buffer_offset_base = 0;
-
-    using IntervalSet = boost::icl::interval_set<CacheAddr>;
-    using IntervalCache = boost::icl::interval_map<CacheAddr, MapInterval>;
-    using IntervalType = typename IntervalCache::interval_type;
-    IntervalCache mapped_addresses{};
-
-    static constexpr u64 write_page_bit{11};
-    std::unordered_map<u64, u32> written_pages{};
-
-    static constexpr u64 block_page_bits{21};
-    static constexpr u64 block_page_size{1 << block_page_bits};
-    std::unordered_map<u64, TBuffer> blocks{};
-
-    std::list<TBuffer> pending_destruction{};
-    u64 epoch{};
-    u64 modified_ticks{};
-
-    std::recursive_mutex mutex;
-};
-
-} // namespace VideoCommon
@@ -1,89 +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/gpu.h"
-
-namespace VideoCommon {
-
-class MapIntervalBase {
-public:
-    MapIntervalBase(const CacheAddr start, const CacheAddr end, const GPUVAddr gpu_addr)
-        : start{start}, end{end}, gpu_addr{gpu_addr} {}
-
-    void SetCpuAddress(VAddr new_cpu_addr) {
-        cpu_addr = new_cpu_addr;
-    }
-
-    VAddr GetCpuAddress() const {
-        return cpu_addr;
-    }
-
-    GPUVAddr GetGpuAddress() const {
-        return gpu_addr;
-    }
-
-    bool IsInside(const CacheAddr other_start, const CacheAddr other_end) const {
-        return (start <= other_start && other_end <= end);
-    }
-
-    bool operator==(const MapIntervalBase& rhs) const {
-        return std::tie(start, end) == std::tie(rhs.start, rhs.end);
-    }
-
-    bool operator!=(const MapIntervalBase& rhs) const {
-        return !operator==(rhs);
-    }
-
-    void MarkAsRegistered(const bool registered) {
-        is_registered = registered;
-    }
-
-    bool IsRegistered() const {
-        return is_registered;
-    }
-
-    CacheAddr GetStart() const {
-        return start;
-    }
-
-    CacheAddr GetEnd() const {
-        return end;
-    }
-
-    void MarkAsModified(const bool is_modified_, const u64 tick) {
-        is_modified = is_modified_;
-        ticks = tick;
-    }
-
-    bool IsModified() const {
-        return is_modified;
-    }
-
-    u64 GetModificationTick() const {
-        return ticks;
-    }
-
-    void MarkAsWritten(const bool is_written_) {
-        is_written = is_written_;
-    }
-
-    bool IsWritten() const {
-        return is_written;
-    }
-
-private:
-    CacheAddr start;
-    CacheAddr end;
-    GPUVAddr gpu_addr;
-    VAddr cpu_addr{};
-    bool is_written{};
-    bool is_modified{};
-    bool is_registered{};
-    u64 ticks{};
-};
-
-} // namespace VideoCommon
@@ -10,7 +10,8 @@

 namespace Tegra::Engines {

-Fermi2D::Fermi2D(VideoCore::RasterizerInterface& rasterizer) : rasterizer{rasterizer} {}
+Fermi2D::Fermi2D(VideoCore::RasterizerInterface& rasterizer, MemoryManager& memory_manager)
+    : rasterizer{rasterizer}, memory_manager{memory_manager} {}

 void Fermi2D::CallMethod(const GPU::MethodCall& method_call) {
    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
@@ -33,7 +33,7 @@ namespace Tegra::Engines {

 class Fermi2D final {
 public:
-    explicit Fermi2D(VideoCore::RasterizerInterface& rasterizer);
+    explicit Fermi2D(VideoCore::RasterizerInterface& rasterizer, MemoryManager& memory_manager);
    ~Fermi2D() = default;

    /// Write the value to the register identified by method.
@@ -145,6 +145,7 @@ public:

 private:
    VideoCore::RasterizerInterface& rasterizer;
+    MemoryManager& memory_manager;

    /// Performs the copy from the source surface to the destination surface as configured in the
    /// registers.
@@ -2,7 +2,6 @@
 // Licensed under GPLv2 or any later version
 // Refer to the license.txt file included.

-#include <bitset>
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core.h"
@@ -50,33 +49,6 @@ void KeplerCompute::CallMethod(const GPU::MethodCall& method_call) {
    }
 }

-Tegra::Texture::FullTextureInfo KeplerCompute::GetTexture(std::size_t offset) const {
-    const std::bitset<8> cbuf_mask = launch_description.const_buffer_enable_mask.Value();
-    ASSERT(cbuf_mask[regs.tex_cb_index]);
-
-    const auto& texinfo = launch_description.const_buffer_config[regs.tex_cb_index];
-    ASSERT(texinfo.Address() != 0);
-
-    const GPUVAddr address = texinfo.Address() + offset * sizeof(Texture::TextureHandle);
-    ASSERT(address < texinfo.Address() + texinfo.size);
-
-    const Texture::TextureHandle tex_handle{memory_manager.Read<u32>(address)};
-    return GetTextureInfo(tex_handle, offset);
-}
-
-Texture::FullTextureInfo KeplerCompute::GetTextureInfo(const Texture::TextureHandle tex_handle,
-                                                       std::size_t offset) const {
-    return Texture::FullTextureInfo{static_cast<u32>(offset), GetTICEntry(tex_handle.tic_id),
-                                    GetTSCEntry(tex_handle.tsc_id)};
-}
-
-u32 KeplerCompute::AccessConstBuffer32(u64 const_buffer, u64 offset) const {
-    const auto& buffer = launch_description.const_buffer_config[const_buffer];
-    u32 result;
-    std::memcpy(&result, memory_manager.GetPointer(buffer.Address() + offset), sizeof(u32));
-    return result;
-}
-
 void KeplerCompute::ProcessLaunch() {
    const GPUVAddr launch_desc_loc = regs.launch_desc_loc.Address();
    memory_manager.ReadBlockUnsafe(launch_desc_loc, &launch_description,
@@ -88,29 +60,4 @@ void KeplerCompute::ProcessLaunch() {
    rasterizer.DispatchCompute(code_addr);
 }

-Texture::TICEntry KeplerCompute::GetTICEntry(u32 tic_index) const {
-    const GPUVAddr tic_address_gpu{regs.tic.Address() + tic_index * sizeof(Texture::TICEntry)};
-
-    Texture::TICEntry tic_entry;
-    memory_manager.ReadBlockUnsafe(tic_address_gpu, &tic_entry, sizeof(Texture::TICEntry));
-
-    const auto r_type{tic_entry.r_type.Value()};
-    const auto g_type{tic_entry.g_type.Value()};
-    const auto b_type{tic_entry.b_type.Value()};
-    const auto a_type{tic_entry.a_type.Value()};
-
-    // TODO(Subv): Different data types for separate components are not supported
-    DEBUG_ASSERT(r_type == g_type && r_type == b_type && r_type == a_type);
-
-    return tic_entry;
-}
-
-Texture::TSCEntry KeplerCompute::GetTSCEntry(u32 tsc_index) const {
-    const GPUVAddr tsc_address_gpu{regs.tsc.Address() + tsc_index * sizeof(Texture::TSCEntry)};
-
-    Texture::TSCEntry tsc_entry;
-    memory_manager.ReadBlockUnsafe(tsc_address_gpu, &tsc_entry, sizeof(Texture::TSCEntry));
-    return tsc_entry;
-}
-
 } // namespace Tegra::Engines
@@ -12,7 +12,6 @@
 #include "common/common_types.h"
 #include "video_core/engines/engine_upload.h"
 #include "video_core/gpu.h"
-#include "video_core/textures/texture.h"

 namespace Core {
 class System;
@@ -112,7 +111,7 @@ public:

                INSERT_PADDING_WORDS(0x3FE);

-                u32 tex_cb_index;
+                u32 texture_const_buffer_index;

                INSERT_PADDING_WORDS(0x374);
            };
@@ -150,7 +149,7 @@ public:
        union {
            BitField<0, 8, u32> const_buffer_enable_mask;
            BitField<29, 2, u32> cache_layout;
-        };
+        } memory_config;

        INSERT_PADDING_WORDS(0x8);

@@ -195,14 +194,6 @@ public:
    /// Write the value to the register identified by method.
    void CallMethod(const GPU::MethodCall& method_call);

-    Tegra::Texture::FullTextureInfo GetTexture(std::size_t offset) const;
-
-    /// Given a Texture Handle, returns the TSC and TIC entries.
-    Texture::FullTextureInfo GetTextureInfo(const Texture::TextureHandle tex_handle,
-                                            std::size_t offset) const;
-
-    u32 AccessConstBuffer32(u64 const_buffer, u64 offset) const;
-
 private:
    Core::System& system;
    VideoCore::RasterizerInterface& rasterizer;
@@ -210,12 +201,6 @@ private:
    Upload::State upload_state;

    void ProcessLaunch();
-
-    /// Retrieves information about a specific TIC entry from the TIC buffer.
-    Texture::TICEntry GetTICEntry(u32 tic_index) const;
-
-    /// Retrieves information about a specific TSC entry from the TSC buffer.
-    Texture::TSCEntry GetTSCEntry(u32 tsc_index) const;
 };

 #define ASSERT_REG_POSITION(field_name, position)                                                  \
@@ -233,12 +218,12 @@ ASSERT_REG_POSITION(launch, 0xAF);
 ASSERT_REG_POSITION(tsc, 0x557);
 ASSERT_REG_POSITION(tic, 0x55D);
 ASSERT_REG_POSITION(code_loc, 0x582);
-ASSERT_REG_POSITION(tex_cb_index, 0x982);
+ASSERT_REG_POSITION(texture_const_buffer_index, 0x982);
 ASSERT_LAUNCH_PARAM_POSITION(program_start, 0x8);
 ASSERT_LAUNCH_PARAM_POSITION(grid_dim_x, 0xC);
 ASSERT_LAUNCH_PARAM_POSITION(shared_alloc, 0x11);
 ASSERT_LAUNCH_PARAM_POSITION(block_dim_x, 0x12);
-ASSERT_LAUNCH_PARAM_POSITION(const_buffer_enable_mask, 0x14);
+ASSERT_LAUNCH_PARAM_POSITION(memory_config, 0x14);
 ASSERT_LAUNCH_PARAM_POSITION(const_buffer_config, 0x1D);

 #undef ASSERT_REG_POSITION
@@ -15,7 +15,7 @@
 namespace Tegra::Engines {

 KeplerMemory::KeplerMemory(Core::System& system, MemoryManager& memory_manager)
-    : system{system}, upload_state{memory_manager, regs.upload} {}
+    : system{system}, memory_manager{memory_manager}, upload_state{memory_manager, regs.upload} {}

 KeplerMemory::~KeplerMemory() = default;

@@ -65,6 +65,7 @@ public:

 private:
    Core::System& system;
+    MemoryManager& memory_manager;
    Upload::State upload_state;
 };

@@ -244,15 +244,21 @@ void Maxwell3D::InitDirtySettings() {
    dirty_pointers[MAXWELL3D_REG_INDEX(polygon_offset_clamp)] = polygon_offset_dirty_reg;
 }

-void Maxwell3D::CallMacroMethod(u32 method, std::size_t num_parameters, const u32* parameters) {
+void Maxwell3D::CallMacroMethod(u32 method, std::vector<u32> parameters) {
    // Reset the current macro.
    executing_macro = 0;

    // Lookup the macro offset
-    const u32 entry = ((method - MacroRegistersStart) >> 1) % macro_positions.size();
+    const u32 entry{(method - MacroRegistersStart) >> 1};
+    const auto& search{macro_offsets.find(entry)};
+    if (search == macro_offsets.end()) {
+        LOG_CRITICAL(HW_GPU, "macro not found for method 0x{:X}!", method);
+        UNREACHABLE();
+        return;
+    }

    // Execute the current macro.
-    macro_interpreter.Execute(macro_positions[entry], num_parameters, parameters);
+    macro_interpreter.Execute(search->second, std::move(parameters));
 }

 void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {
@@ -289,8 +295,7 @@ void Maxwell3D::CallMethod(const GPU::MethodCall& method_call) {

        // Call the macro when there are no more parameters in the command buffer
        if (method_call.IsLastCall()) {
-            CallMacroMethod(executing_macro, macro_params.size(), macro_params.data());
-            macro_params.clear();
+            CallMacroMethod(executing_macro, std::move(macro_params));
        }
        return;
    }
@@ -416,7 +421,7 @@ void Maxwell3D::ProcessMacroUpload(u32 data) {
 }

 void Maxwell3D::ProcessMacroBind(u32 data) {
-    macro_positions[regs.macros.entry++] = data;
+    macro_offsets[regs.macros.entry] = data;
 }

 void Maxwell3D::ProcessQueryGet() {
@@ -519,7 +524,7 @@ void Maxwell3D::ProcessQueryCondition() {
 void Maxwell3D::ProcessSyncPoint() {
    const u32 sync_point = regs.sync_info.sync_point.Value();
    const u32 increment = regs.sync_info.increment.Value();
-    [[maybe_unused]] const u32 cache_flush = regs.sync_info.unknown.Value();
+    const u32 cache_flush = regs.sync_info.unknown.Value();
    if (increment) {
        system.GPU().IncrementSyncPoint(sync_point);
    }
@@ -621,10 +626,10 @@ Texture::TICEntry Maxwell3D::GetTICEntry(u32 tic_index) const {
    Texture::TICEntry tic_entry;
    memory_manager.ReadBlockUnsafe(tic_address_gpu, &tic_entry, sizeof(Texture::TICEntry));

-    [[maybe_unused]] const auto r_type{tic_entry.r_type.Value()};
-    [[maybe_unused]] const auto g_type{tic_entry.g_type.Value()};
-    [[maybe_unused]] const auto b_type{tic_entry.b_type.Value()};
-    [[maybe_unused]] const auto a_type{tic_entry.a_type.Value()};
+    const auto r_type{tic_entry.r_type.Value()};
+    const auto g_type{tic_entry.g_type.Value()};
+    const auto b_type{tic_entry.b_type.Value()};
+    const auto a_type{tic_entry.a_type.Value()};

    // TODO(Subv): Different data types for separate components are not supported
    DEBUG_ASSERT(r_type == g_type && r_type == b_type && r_type == a_type);
@@ -62,7 +62,6 @@ public:
        static constexpr std::size_t NumVertexAttributes = 32;
        static constexpr std::size_t NumVaryings = 31;
        static constexpr std::size_t NumTextureSamplers = 32;
-        static constexpr std::size_t NumImages = 8; // TODO(Rodrigo): Investigate this number
        static constexpr std::size_t NumClipDistances = 8;
        static constexpr std::size_t MaxShaderProgram = 6;
        static constexpr std::size_t MaxShaderStage = 5;
@@ -1271,7 +1270,7 @@ private:
    MemoryManager& memory_manager;

    /// Start offsets of each macro in macro_memory
-    std::array<u32, 0x80> macro_positions = {};
+    std::unordered_map<u32, u32> macro_offsets;

    /// Memory for macro code
    MacroMemory macro_memory;
@@ -1308,10 +1307,9 @@ private:
    /**
     * Call a macro on this engine.
     * @param method Method to call
-     * @param num_parameters Number of arguments
     * @param parameters Arguments to the method call
     */
-    void CallMacroMethod(u32 method, std::size_t num_parameters, const u32* parameters);
+    void CallMacroMethod(u32 method, std::vector<u32> parameters);

    /// Handles writes to the macro uploading register.
    void ProcessMacroUpload(u32 data);
@@ -5,17 +5,18 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core.h"
-#include "core/settings.h"
 #include "video_core/engines/maxwell_3d.h"
 #include "video_core/engines/maxwell_dma.h"
 #include "video_core/memory_manager.h"
+#include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_base.h"
 #include "video_core/textures/decoders.h"

 namespace Tegra::Engines {

-MaxwellDMA::MaxwellDMA(Core::System& system, MemoryManager& memory_manager)
-    : system{system}, memory_manager{memory_manager} {}
+MaxwellDMA::MaxwellDMA(Core::System& system, VideoCore::RasterizerInterface& rasterizer,
+                       MemoryManager& memory_manager)
+    : system{system}, rasterizer{rasterizer}, memory_manager{memory_manager} {}

 void MaxwellDMA::CallMethod(const GPU::MethodCall& method_call) {
    ASSERT_MSG(method_call.method < Regs::NUM_REGS,
@@ -83,17 +84,13 @@ void MaxwellDMA::HandleCopy() {
    ASSERT(regs.exec.enable_2d == 1);

    if (regs.exec.is_dst_linear && !regs.exec.is_src_linear) {
-        ASSERT(regs.src_params.BlockDepth() == 0);
+        ASSERT(regs.src_params.size_z == 1);
        // If the input is tiled and the output is linear, deswizzle the input and copy it over.
-        const u32 bytes_per_pixel = regs.dst_pitch / regs.x_count;
+        const u32 src_bytes_per_pixel = regs.src_pitch / regs.src_params.size_x;
        const std::size_t src_size = Texture::CalculateSize(
-            true, bytes_per_pixel, regs.src_params.size_x, regs.src_params.size_y,
+            true, src_bytes_per_pixel, regs.src_params.size_x, regs.src_params.size_y,
            regs.src_params.size_z, regs.src_params.BlockHeight(), regs.src_params.BlockDepth());

-        const std::size_t src_layer_size = Texture::CalculateSize(
-            true, bytes_per_pixel, regs.src_params.size_x, regs.src_params.size_y, 1,
-            regs.src_params.BlockHeight(), regs.src_params.BlockDepth());
-
        const std::size_t dst_size = regs.dst_pitch * regs.y_count;

        if (read_buffer.size() < src_size) {
@@ -107,23 +104,23 @@ void MaxwellDMA::HandleCopy() {
        memory_manager.ReadBlock(source, read_buffer.data(), src_size);
        memory_manager.ReadBlock(dest, write_buffer.data(), dst_size);

-        Texture::UnswizzleSubrect(
-            regs.x_count, regs.y_count, regs.dst_pitch, regs.src_params.size_x, bytes_per_pixel,
-            read_buffer.data() + src_layer_size * regs.src_params.pos_z, write_buffer.data(),
-            regs.src_params.BlockHeight(), regs.src_params.pos_x, regs.src_params.pos_y);
+        Texture::UnswizzleSubrect(regs.x_count, regs.y_count, regs.dst_pitch,
+                                  regs.src_params.size_x, src_bytes_per_pixel, read_buffer.data(),
+                                  write_buffer.data(), regs.src_params.BlockHeight(),
+                                  regs.src_params.pos_x, regs.src_params.pos_y);

        memory_manager.WriteBlock(dest, write_buffer.data(), dst_size);
    } else {
        ASSERT(regs.dst_params.BlockDepth() == 0);

-        const u32 bytes_per_pixel = regs.src_pitch / regs.x_count;
+        const u32 src_bytes_per_pixel = regs.src_pitch / regs.x_count;

        const std::size_t dst_size = Texture::CalculateSize(
-            true, bytes_per_pixel, regs.dst_params.size_x, regs.dst_params.size_y,
+            true, src_bytes_per_pixel, regs.dst_params.size_x, regs.dst_params.size_y,
            regs.dst_params.size_z, regs.dst_params.BlockHeight(), regs.dst_params.BlockDepth());

        const std::size_t dst_layer_size = Texture::CalculateSize(
-            true, bytes_per_pixel, regs.dst_params.size_x, regs.dst_params.size_y, 1,
+            true, src_bytes_per_pixel, regs.dst_params.size_x, regs.dst_params.size_y, 1,
            regs.dst_params.BlockHeight(), regs.dst_params.BlockDepth());

        const std::size_t src_size = regs.src_pitch * regs.y_count;
@@ -136,19 +133,14 @@ void MaxwellDMA::HandleCopy() {
            write_buffer.resize(dst_size);
        }

-        if (Settings::values.use_accurate_gpu_emulation) {
-            memory_manager.ReadBlock(source, read_buffer.data(), src_size);
-            memory_manager.ReadBlock(dest, write_buffer.data(), dst_size);
-        } else {
-            memory_manager.ReadBlockUnsafe(source, read_buffer.data(), src_size);
-            memory_manager.ReadBlockUnsafe(dest, write_buffer.data(), dst_size);
-        }
+        memory_manager.ReadBlock(source, read_buffer.data(), src_size);
+        memory_manager.ReadBlock(dest, write_buffer.data(), dst_size);

        // If the input is linear and the output is tiled, swizzle the input and copy it over.
-        Texture::SwizzleSubrect(
-            regs.x_count, regs.y_count, regs.src_pitch, regs.dst_params.size_x, bytes_per_pixel,
-            write_buffer.data() + dst_layer_size * regs.dst_params.pos_z, read_buffer.data(),
-            regs.dst_params.BlockHeight(), regs.dst_params.pos_x, regs.dst_params.pos_y);
+        Texture::SwizzleSubrect(regs.x_count, regs.y_count, regs.src_pitch, regs.dst_params.size_x,
+                                src_bytes_per_pixel,
+                                write_buffer.data() + dst_layer_size * regs.dst_params.pos_z,
+                                read_buffer.data(), regs.dst_params.BlockHeight());

        memory_manager.WriteBlock(dest, write_buffer.data(), dst_size);
    }
@@ -20,6 +20,10 @@ namespace Tegra {
 class MemoryManager;
 }

+namespace VideoCore {
+class RasterizerInterface;
+}
+
 namespace Tegra::Engines {

 /**
@@ -29,7 +33,8 @@ namespace Tegra::Engines {

 class MaxwellDMA final {
 public:
-    explicit MaxwellDMA(Core::System& system, MemoryManager& memory_manager);
+    explicit MaxwellDMA(Core::System& system, VideoCore::RasterizerInterface& rasterizer,
+                        MemoryManager& memory_manager);
    ~MaxwellDMA() = default;

    /// Write the value to the register identified by method.
@@ -175,6 +180,8 @@ public:
 private:
    Core::System& system;

+    VideoCore::RasterizerInterface& rasterizer;
+
    MemoryManager& memory_manager;

    std::vector<u8> read_buffer;
@@ -538,34 +538,6 @@ enum class PhysicalAttributeDirection : u64 {
    Output = 1,
 };

-enum class VoteOperation : u64 {
-    All = 0, // allThreadsNV
-    Any = 1, // anyThreadNV
-    Eq = 2,  // allThreadsEqualNV
-};
-
-enum class ImageAtomicSize : u64 {
-    U32 = 0,
-    S32 = 1,
-    U64 = 2,
-    F32 = 3,
-    S64 = 5,
-    SD32 = 6,
-    SD64 = 7,
-};
-
-enum class ImageAtomicOperation : u64 {
-    Add = 0,
-    Min = 1,
-    Max = 2,
-    Inc = 3,
-    Dec = 4,
-    And = 5,
-    Or = 6,
-    Xor = 7,
-    Exch = 8,
-};
-
 union Instruction {
    Instruction& operator=(const Instruction& instr) {
        value = instr.value;
@@ -592,13 +564,6 @@ union Instruction {
        BitField<13, 1, u64> trigger;
    } nop;

-    union {
-        BitField<48, 2, VoteOperation> operation;
-        BitField<45, 3, u64> dest_pred;
-        BitField<39, 3, u64> value;
-        BitField<42, 1, u64> negate_value;
-    } vote;
-
    union {
        BitField<8, 8, Register> gpr;
        BitField<20, 24, s64> offset;
@@ -696,10 +661,6 @@ union Instruction {
        BitField<48, 1, u64> is_signed;
    } shift;

-    union {
-        BitField<39, 1, u64> wrap;
-    } shr;
-
    union {
        BitField<39, 5, u64> shift_amount;
        BitField<48, 1, u64> negate_b;
@@ -912,7 +873,6 @@ union Instruction {
    union {
        BitField<0, 3, u64> pred0;
        BitField<3, 3, u64> pred3;
-        BitField<6, 1, u64> neg_b;
        BitField<7, 1, u64> abs_a;
        BitField<39, 3, u64> pred39;
        BitField<42, 1, u64> neg_pred;
@@ -1046,6 +1006,7 @@ union Instruction {
    } iset;

    union {
+        BitField<41, 2, u64> selector; // i2i and i2f only
        BitField<45, 1, u64> negate_a;
        BitField<49, 1, u64> abs_a;
        BitField<10, 2, Register::Size> src_size;
@@ -1071,13 +1032,6 @@ union Instruction {
            }
        } f2f;

-        union {
-            BitField<41, 2, u64> selector;
-        } int_src;
-
-        union {
-            BitField<41, 1, u64> selector;
-        } float_src;
    } conversion;

    union {
@@ -1413,14 +1367,6 @@ union Instruction {
        }
    } sust;

-    union {
-        BitField<28, 1, u64> is_ba;
-        BitField<51, 3, ImageAtomicSize> size;
-        BitField<33, 3, ImageType> image_type;
-        BitField<29, 4, ImageAtomicOperation> operation;
-        BitField<49, 2, OutOfBoundsStore> out_of_bounds_store;
-    } suatom_d;
-
    union {
        BitField<20, 24, u64> target;
        BitField<5, 1, u64> constant_buffer;
@@ -1541,7 +1487,6 @@ public:
        SYNC,
        BRK,
        DEPBAR,
-        VOTE,
        BFE_C,
        BFE_R,
        BFE_IMM,
@@ -1573,7 +1518,6 @@ public:
        TMML_B, // Texture Mip Map Level
        TMML,   // Texture Mip Map Level
        SUST,   // Surface Store
-        SUATOM, // Surface Atomic Operation
        EXIT,
        NOP,
        IPA,
@@ -1705,7 +1649,6 @@ public:
        Hfma2,
        Flow,
        Synch,
-        Warp,
        Memory,
        Texture,
        Image,
@@ -1832,7 +1775,6 @@ private:
            INST("111000110100---", Id::BRK, Type::Flow, "BRK"),
            INST("111000110000----", Id::EXIT, Type::Flow, "EXIT"),
            INST("1111000011110---", Id::DEPBAR, Type::Synch, "DEPBAR"),
-            INST("0101000011011---", Id::VOTE, Type::Warp, "VOTE"),
            INST("1110111111011---", Id::LD_A, Type::Memory, "LD_A"),
            INST("1110111101001---", Id::LD_S, Type::Memory, "LD_S"),
            INST("1110111101000---", Id::LD_L, Type::Memory, "LD_L"),
@@ -1857,7 +1799,6 @@ private:
            INST("110111110110----", Id::TMML_B, Type::Texture, "TMML_B"),
            INST("1101111101011---", Id::TMML, Type::Texture, "TMML"),
            INST("11101011001-----", Id::SUST, Type::Image, "SUST"),
-            INST("1110101000------", Id::SUATOM, Type::Image, "SUATOM_D"),
            INST("0101000010110---", Id::NOP, Type::Trivial, "NOP"),
            INST("11100000--------", Id::IPA, Type::Trivial, "IPA"),
            INST("1111101111100---", Id::OUT_R, Type::Trivial, "OUT_R"),
@@ -17,15 +17,27 @@

 namespace Tegra {

+u32 FramebufferConfig::BytesPerPixel(PixelFormat format) {
+    switch (format) {
+    case PixelFormat::ABGR8:
+    case PixelFormat::BGRA8:
+        return 4;
+    default:
+        return 4;
+    }
+
+    UNREACHABLE();
+}
+
 GPU::GPU(Core::System& system, VideoCore::RendererBase& renderer, bool is_async)
    : system{system}, renderer{renderer}, is_async{is_async} {
    auto& rasterizer{renderer.Rasterizer()};
    memory_manager = std::make_unique<Tegra::MemoryManager>(system, rasterizer);
    dma_pusher = std::make_unique<Tegra::DmaPusher>(*this);
    maxwell_3d = std::make_unique<Engines::Maxwell3D>(system, rasterizer, *memory_manager);
-    fermi_2d = std::make_unique<Engines::Fermi2D>(rasterizer);
+    fermi_2d = std::make_unique<Engines::Fermi2D>(rasterizer, *memory_manager);
    kepler_compute = std::make_unique<Engines::KeplerCompute>(system, rasterizer, *memory_manager);
-    maxwell_dma = std::make_unique<Engines::MaxwellDMA>(system, *memory_manager);
+    maxwell_dma = std::make_unique<Engines::MaxwellDMA>(system, rasterizer, *memory_manager);
    kepler_memory = std::make_unique<Engines::KeplerMemory>(system, *memory_manager);
 }

@@ -19,10 +19,6 @@ inline CacheAddr ToCacheAddr(const void* host_ptr) {
    return reinterpret_cast<CacheAddr>(host_ptr);
 }

-inline u8* FromCacheAddr(CacheAddr cache_addr) {
-    return reinterpret_cast<u8*>(cache_addr);
-}
-
 namespace Core {
 class System;
 }
@@ -95,10 +91,14 @@ class DebugContext;
 struct FramebufferConfig {
    enum class PixelFormat : u32 {
        ABGR8 = 1,
-        RGB565 = 4,
        BGRA8 = 5,
    };

+    /**
+     * Returns the number of bytes per pixel.
+     */
+    static u32 BytesPerPixel(PixelFormat format);
+
    VAddr address;
    u32 offset;
    u32 width;
@@ -249,7 +249,8 @@ public:
    virtual void PushGPUEntries(Tegra::CommandList&& entries) = 0;

    /// Swap buffers (render frame)
-    virtual void SwapBuffers(const Tegra::FramebufferConfig* framebuffer) = 0;
+    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(CacheAddr addr, u64 size) = 0;
@@ -280,8 +281,8 @@ private:

 protected:
    std::unique_ptr<Tegra::DmaPusher> dma_pusher;
-    Core::System& system;
    VideoCore::RendererBase& renderer;
+    Core::System& system;

 private:
    std::unique_ptr<Tegra::MemoryManager> memory_manager;