Merge branch 'master' into gl_snorm

2022-11-04 13:28:10 +08:00
parent 7b78a6f8d7 38e4382f53
commit 0514da65f0
503 changed files with 41443 additions and 21017 deletions
@@ -33,16 +33,14 @@ DESTDIR="$PWD/AppDir" ninja install
 rm -vf AppDir/usr/bin/yuzu-cmd AppDir/usr/bin/yuzu-tester

 # Download tools needed to build an AppImage
-wget -nc https://github.com/yuzu-emu/ext-linux-bin/raw/main/appimage/linuxdeploy-x86_64.AppImage
-wget -nc https://github.com/yuzu-emu/ext-linux-bin/raw/main/appimage/linuxdeploy-plugin-qt-x86_64.AppImage
+wget -nc https://raw.githubusercontent.com/yuzu-emu/ext-linux-bin/main/gcc/deploy-linux.sh
 wget -nc https://raw.githubusercontent.com/yuzu-emu/AppImageKit-checkrt/old/AppRun.sh
 wget -nc https://github.com/yuzu-emu/ext-linux-bin/raw/main/appimage/exec-x86_64.so
 # Set executable bit
 chmod 755 \
+    deploy-linux.sh \
    AppRun.sh \
    exec-x86_64.so \
-    linuxdeploy-x86_64.AppImage \
-    linuxdeploy-plugin-qt-x86_64.AppImage

 # Workaround for https://github.com/AppImage/AppImageKit/issues/828
 export APPIMAGE_EXTRACT_AND_RUN=1
@@ -52,7 +50,7 @@ mkdir -p AppDir/usr/optional/libstdc++
 mkdir -p AppDir/usr/optional/libgcc_s

 # Deploy yuzu's needed dependencies
-./linuxdeploy-x86_64.AppImage --appdir AppDir --plugin qt
+DEPLOY_QT=1 ./deploy-linux.sh AppDir/usr/bin/yuzu AppDir

 # Workaround for libQt5MultimediaGstTools indirectly requiring libwayland-client and breaking Vulkan usage on end-user systems
 find AppDir -type f -regex '.*libwayland-client\.so.*' -delete -print
@@ -3,15 +3,6 @@
 # SPDX-FileCopyrightText: 2021 yuzu Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later

-# Setup RC file for tx
-cat << EOF > ~/.transifexrc
-[https://www.transifex.com]
-hostname = https://www.transifex.com
-username = api
-password = $TRANSIFEX_API_TOKEN
-EOF
-
-
 set -x

 echo -e "\e[1m\e[33mBuild tools information:\e[0m"
@@ -19,9 +10,6 @@ cmake --version
 gcc -v
 tx --version

-# vcpkg needs these: curl zip unzip tar, have tar
-apt-get install -y curl zip unzip
-
 mkdir build && cd build
 cmake .. -DENABLE_QT_TRANSLATION=ON -DGENERATE_QT_TRANSLATION=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_SDL2=OFF -DYUZU_TESTS=OFF -DYUZU_USE_BUNDLED_VCPKG=ON
 make translation
@@ -10,13 +10,9 @@ set -e
 ccache -sv

 mkdir -p build && cd build
-export LDFLAGS="-fuse-ld=lld"
-# -femulated-tls required due to an incompatibility between GCC and Clang
-# TODO(lat9nq): If this is widespread, we probably need to add this to CMakeLists where appropriate
-export CXXFLAGS="-femulated-tls"
 cmake .. \
    -DCMAKE_BUILD_TYPE=Release \
-    -DCMAKE_TOOLCHAIN_FILE="${PWD}/../CMakeModules/MinGWClangCross.cmake" \
+    -DCMAKE_TOOLCHAIN_FILE="${PWD}/../CMakeModules/MinGWCross.cmake" \
    -DDISPLAY_VERSION="$1" \
    -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON \
    -DENABLE_QT_TRANSLATION=ON \
@@ -19,11 +19,11 @@ jobs:
      - uses: actions/checkout@v3
        with:
          submodules: recursive
-          fetch-depth: 0   
+          fetch-depth: 0
      - name: Update Translation
        run: ./.ci/scripts/transifex/docker.sh
        env:
-          TRANSIFEX_API_TOKEN: ${{ secrets.TRANSIFEX_API_TOKEN }}
+          TX_TOKEN: ${{ secrets.TRANSIFEX_API_TOKEN }}

  reuse:
    runs-on: ubuntu-latest
@@ -252,7 +252,7 @@ if(ENABLE_QT)
            endif()

            # Check for headers
-            Include(FindPkgConfig REQUIRED)
+            find_package(PkgConfig REQUIRED)
            pkg_check_modules(QT_DEP_GLU QUIET glu>=9.0.0)
            if (NOT QT_DEP_GLU_FOUND)
                message(FATAL_ERROR "Qt bundled pacakge dependency `glu` not found. \
@@ -386,7 +386,7 @@ endif()

 # Ensure libusb is properly configured (based on dolphin libusb include)
 if(NOT APPLE AND NOT YUZU_USE_BUNDLED_LIBUSB)
-    include(FindPkgConfig)
+    find_package(PkgConfig)
    if (PKG_CONFIG_FOUND AND NOT CMAKE_SYSTEM_NAME MATCHES "DragonFly|FreeBSD")
        pkg_check_modules(LIBUSB QUIET libusb-1.0>=1.0.24)
    else()
@@ -410,7 +410,7 @@ set(FFmpeg_COMPONENTS
    swscale)

 if (UNIX AND NOT APPLE)
-    Include(FindPkgConfig REQUIRED)
+    find_package(PkgConfig REQUIRED)
    pkg_check_modules(LIBVA libva)
 endif()
 if (NOT YUZU_USE_BUNDLED_FFMPEG)
@@ -541,9 +541,9 @@ add_definitions(-DBOOST_ERROR_CODE_HEADER_ONLY
 # Adjustments for MSVC + Ninja
 if (MSVC AND CMAKE_GENERATOR STREQUAL "Ninja")
    add_compile_options(
-        /wd4711 # function 'function' selected for automatic inline expansion
        /wd4464 # relative include path contains '..'
-        /wd4820 # 'identifier1': '4' bytes padding added after data member 'identifier2'
+        /wd4711 # function 'function' selected for automatic inline expansion
+        /wd4820 # 'bytes' bytes padding added after construct 'member_name'
    )
 endif()

@@ -1,7 +1,7 @@
 [main]
 host = https://www.transifex.com

-[yuzu.emulator]
+[o:yuzu-emulator:p:yuzu:r:emulator]
 file_filter = <lang>.ts
 source_file = en.ts
 source_lang = en
@@ -1 +1,3 @@
-This directory stores translation patches (TS files) for yuzu Qt frontend. This directory is linked with [yuzu project on transifex](https://www.transifex.com/yuzu-emulator/yuzu), so you can update the translation by executing `tx pull -a`. If you want to contribute to the translation, please go the transifex link and submit your translation there. This directory on the main repo will be synchronized with transifex periodically. Do not directly open PRs on github to modify the translation.
+This directory stores translation patches (TS files) for yuzu Qt frontend. This directory is linked with [yuzu project on transifex](https://www.transifex.com/yuzu-emulator/yuzu), so you can update the translation by executing `tx pull -t -a`. If you want to contribute to the translation, please go the transifex link and submit your translation there. This directory on the main repo will be synchronized with transifex periodically.
+
+Do not directly open PRs on github to modify the translation.
@@ -43,7 +43,7 @@ if (NOT WIN32)
            CACHE PATH "Paths to FFmpeg libraries" FORCE)
    endforeach()

-    Include(FindPkgConfig REQUIRED)
+    find_package(PkgConfig REQUIRED)
    pkg_check_modules(LIBVA libva)
    pkg_check_modules(CUDA cuda)
    pkg_check_modules(FFNVCODEC ffnvcodec)
@@ -108,7 +108,7 @@ if (MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux") OR APPLE)
    target_include_directories(usb INTERFACE "${LIBUSB_INCLUDE_DIRS}")

    if (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
-        Include(FindPkgConfig)
+        find_package(PkgConfig)
        pkg_check_modules(LIBUDEV REQUIRED libudev)

        if (LIBUDEV_FOUND)
@@ -58,13 +58,11 @@ if (MSVC)

        # Warnings
        /W3
-        /we4018 # 'expression': signed/unsigned mismatch
+        /WX
+
        /we4062 # Enumerator 'identifier' in a switch of enum 'enumeration' is not handled
-        /we4101 # 'identifier': unreferenced local variable
        /we4189 # 'identifier': local variable is initialized but not referenced
        /we4265 # 'class': class has virtual functions, but destructor is not virtual
-        /we4267 # 'var': conversion from 'size_t' to 'type', possible loss of data
-        /we4305 # 'context': truncation from 'type1' to 'type2'
        /we4388 # 'expression': signed/unsigned mismatch
        /we4389 # 'operator': signed/unsigned mismatch
        /we4456 # Declaration of 'identifier' hides previous local declaration
@@ -75,10 +73,13 @@ if (MSVC)
        /we4547 # 'operator': operator before comma has no effect; expected operator with side-effect
        /we4549 # 'operator1': operator before comma has no effect; did you intend 'operator2'?
        /we4555 # Expression has no effect; expected expression with side-effect
-        /we4715 # 'function': not all control paths return a value
-        /we4834 # Discarding return value of function with 'nodiscard' attribute
+        /we4826 # Conversion from 'type1' to 'type2' is sign-extended. This may cause unexpected runtime behavior.
        /we5038 # data member 'member1' will be initialized after data member 'member2'
+        /we5233 # explicit lambda capture 'identifier' is not used
        /we5245 # 'function': unreferenced function with internal linkage has been removed
+
+        /wd4100 # 'identifier': unreferenced formal parameter
+        /wd4324 # 'struct_name': structure was padded due to __declspec(align())
    )

    if (USE_CCACHE)
@@ -99,28 +100,23 @@ if (MSVC)
    set(CMAKE_EXE_LINKER_FLAGS_RELEASE "/DEBUG /MANIFEST:NO /INCREMENTAL:NO /OPT:REF,ICF" CACHE STRING "" FORCE)
 else()
    add_compile_options(
-        -Wall
-        -Werror=array-bounds
-        -Werror=implicit-fallthrough
+        -Werror=all
+        -Werror=extra
        -Werror=missing-declarations
-        -Werror=missing-field-initializers
-        -Werror=reorder
        -Werror=shadow
-        -Werror=sign-compare
-        -Werror=switch
-        -Werror=uninitialized
-        -Werror=unused-function
-        -Werror=unused-result
-        -Werror=unused-variable
-        -Wextra
-        -Wmissing-declarations
+        -Werror=unused
+
        -Wno-attributes
        -Wno-invalid-offsetof
        -Wno-unused-parameter
+
+        $<$<CXX_COMPILER_ID:Clang>:-Wno-braced-scalar-init>
+        $<$<CXX_COMPILER_ID:Clang>:-Wno-unused-private-field>
    )

    if (ARCHITECTURE_x86_64)
        add_compile_options("-mcx16")
+        add_compile_options("-fwrapv")
    endif()

    if (APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL Clang)
@@ -206,20 +206,11 @@ if (MSVC)
        /we4244 # 'conversion': conversion from 'type1' to 'type2', possible loss of data
        /we4245 # 'conversion': conversion from 'type1' to 'type2', signed/unsigned mismatch
        /we4254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
-        /we4456 # Declaration of 'identifier' hides previous local declaration
-        /we4457 # Declaration of 'identifier' hides function parameter
-        /we4458 # Declaration of 'identifier' hides class member
-        /we4459 # Declaration of 'identifier' hides global declaration
+        /we4800 # Implicit conversion from 'type' to bool. Possible information loss
    )
 else()
    target_compile_options(audio_core PRIVATE
        -Werror=conversion
-        -Werror=ignored-qualifiers
-        -Werror=shadow
-        -Werror=unused-variable
-
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>

        -Wno-sign-conversion
    )
@@ -23,7 +23,7 @@ System::~System() {
 void System::Finalize() {
    Stop();
    session->Finalize();
-    buffer_event->GetWritableEvent().Signal();
+    buffer_event->Signal();
 }

 void System::StartSession() {
@@ -56,7 +56,7 @@ Result System::IsConfigValid(const std::string_view device_name,
    return ResultSuccess;
 }

-Result System::Initialize(std::string& device_name, const AudioInParameter& in_params,
+Result System::Initialize(std::string device_name, const AudioInParameter& in_params,
                          const u32 handle_, const u64 applet_resource_user_id_) {
    auto result{IsConfigValid(device_name, in_params)};
    if (result.IsError()) {
@@ -142,7 +142,7 @@ void System::ReleaseBuffers() {

    if (signal) {
        // Signal if any buffer was released, or if none are registered, we need more.
-        buffer_event->GetWritableEvent().Signal();
+        buffer_event->Signal();
    }
 }

@@ -159,7 +159,7 @@ bool System::FlushAudioInBuffers() {
    buffers.FlushBuffers(buffers_released);

    if (buffers_released > 0) {
-        buffer_event->GetWritableEvent().Signal();
+        buffer_event->Signal();
    }
    return true;
 }
@@ -97,7 +97,7 @@ public:
     * @param applet_resource_user_id - Unused.
     * @return Result code.
     */
-    Result Initialize(std::string& device_name, const AudioInParameter& in_params, u32 handle,
+    Result Initialize(std::string device_name, const AudioInParameter& in_params, u32 handle,
                      u64 applet_resource_user_id);

    /**
@@ -24,7 +24,7 @@ System::~System() {
 void System::Finalize() {
    Stop();
    session->Finalize();
-    buffer_event->GetWritableEvent().Signal();
+    buffer_event->Signal();
 }

 std::string_view System::GetDefaultOutputDeviceName() const {
@@ -49,8 +49,8 @@ Result System::IsConfigValid(std::string_view device_name,
    return Service::Audio::ERR_INVALID_CHANNEL_COUNT;
 }

-Result System::Initialize(std::string& device_name, const AudioOutParameter& in_params, u32 handle_,
-                          u64& applet_resource_user_id_) {
+Result System::Initialize(std::string device_name, const AudioOutParameter& in_params, u32 handle_,
+                          u64 applet_resource_user_id_) {
    auto result = IsConfigValid(device_name, in_params);
    if (result.IsError()) {
        return result;
@@ -141,7 +141,7 @@ void System::ReleaseBuffers() {
    bool signal{buffers.ReleaseBuffers(system.CoreTiming(), *session)};
    if (signal) {
        // Signal if any buffer was released, or if none are registered, we need more.
-        buffer_event->GetWritableEvent().Signal();
+        buffer_event->Signal();
    }
 }

@@ -158,7 +158,7 @@ bool System::FlushAudioOutBuffers() {
    buffers.FlushBuffers(buffers_released);

    if (buffers_released > 0) {
-        buffer_event->GetWritableEvent().Signal();
+        buffer_event->Signal();
    }
    return true;
 }
@@ -88,8 +88,8 @@ public:
     * @param applet_resource_user_id - Unused.
     * @return Result code.
     */
-    Result Initialize(std::string& device_name, const AudioOutParameter& in_params, u32 handle,
-                      u64& applet_resource_user_id);
+    Result Initialize(std::string device_name, const AudioOutParameter& in_params, u32 handle,
+                      u64 applet_resource_user_id);

    /**
     * Start this system.
@@ -132,7 +132,7 @@ void AudioRenderer::CreateSinkStreams() {
 }

 void AudioRenderer::ThreadFunc() {
-    constexpr char name[]{"yuzu:AudioRenderer"};
+    constexpr char name[]{"AudioRenderer"};
    MicroProfileOnThreadCreate(name);
    Common::SetCurrentThreadName(name);
    Common::SetCurrentThreadPriority(Common::ThreadPriority::Critical);
@@ -91,7 +91,7 @@ Result InfoUpdater::UpdateVoices(VoiceContext& voice_context,
            voice_info.Initialize();

            for (u32 channel = 0; channel < in_param.channel_count; channel++) {
-                std::memset(voice_states[channel], 0, sizeof(VoiceState));
+                *voice_states[channel] = {};
            }
        }

@@ -94,7 +94,7 @@ void BiquadFilterCommand::Dump([[maybe_unused]] const ADSP::CommandListProcessor
 void BiquadFilterCommand::Process(const ADSP::CommandListProcessor& processor) {
    auto state_{reinterpret_cast<VoiceState::BiquadFilterState*>(state)};
    if (needs_init) {
-        std::memset(state_, 0, sizeof(VoiceState::BiquadFilterState));
+        *state_ = {};
    }

    auto input_buffer{
@@ -30,7 +30,7 @@ void MultiTapBiquadFilterCommand::Process(const ADSP::CommandListProcessor& proc
    for (u32 i = 0; i < filter_tap_count; i++) {
        auto state{reinterpret_cast<VoiceState::BiquadFilterState*>(states[i])};
        if (needs_init[i]) {
-            std::memset(state, 0, sizeof(VoiceState::BiquadFilterState));
+            *state = {};
        }

        ApplyBiquadFilterFloat(output_buffer, input_buffer, biquads[i].b, biquads[i].a, *state,
@@ -98,9 +98,8 @@ System::System(Core::System& core_, Kernel::KEvent* adsp_rendered_event_)
    : core{core_}, adsp{core.AudioCore().GetADSP()}, adsp_rendered_event{adsp_rendered_event_} {}

 Result System::Initialize(const AudioRendererParameterInternal& params,
-                          Kernel::KTransferMemory* transfer_memory, const u64 transfer_memory_size,
-                          const u32 process_handle_, const u64 applet_resource_user_id_,
-                          const s32 session_id_) {
+                          Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size,
+                          u32 process_handle_, u64 applet_resource_user_id_, s32 session_id_) {
    if (!CheckValidRevision(params.revision)) {
        return Service::Audio::ERR_INVALID_REVISION;
    }
@@ -354,6 +353,8 @@ Result System::Initialize(const AudioRendererParameterInternal& params,

    render_time_limit_percent = 100;
    drop_voice = params.voice_drop_enabled && params.execution_mode == ExecutionMode::Auto;
+    drop_voice_param = 1.0f;
+    num_voices_dropped = 0;

    allocator.Align(0x40);
    command_workbuffer_size = allocator.GetRemainingSize();
@@ -534,7 +535,7 @@ Result System::Update(std::span<const u8> input, std::span<u8> performance, std:
        return result;
    }

-    adsp_rendered_event->GetWritableEvent().Clear();
+    adsp_rendered_event->Clear();
    num_times_updated++;

    const auto end_time{core.CoreTiming().GetClockTicks()};
@@ -547,7 +548,7 @@ u32 System::GetRenderingTimeLimit() const {
    return render_time_limit_percent;
 }

-void System::SetRenderingTimeLimit(const u32 limit) {
+void System::SetRenderingTimeLimit(u32 limit) {
    render_time_limit_percent = limit;
 }

@@ -625,7 +626,7 @@ void System::SendCommandToDsp() {
            reset_command_buffers = false;
            command_buffer_size = command_size;
            if (remaining_command_count == 0) {
-                adsp_rendered_event->GetWritableEvent().Signal();
+                adsp_rendered_event->Signal();
            }
        } else {
            adsp.ClearRemainCount(session_id);
@@ -635,7 +636,7 @@ void System::SendCommandToDsp() {
 }

 u64 System::GenerateCommand(std::span<u8> in_command_buffer,
-                            [[maybe_unused]] const u64 command_buffer_size_) {
+                            [[maybe_unused]] u64 command_buffer_size_) {
    PoolMapper::ClearUseState(memory_pool_workbuffer, memory_pool_count);
    const auto start_time{core.CoreTiming().GetClockTicks()};

@@ -693,7 +694,8 @@ u64 System::GenerateCommand(std::span<u8> in_command_buffer,

    voice_context.SortInfo();

-    const auto start_estimated_time{command_buffer.estimated_process_time};
+    const auto start_estimated_time{drop_voice_param *
+                                    static_cast<f32>(command_buffer.estimated_process_time)};

    command_generator.GenerateVoiceCommands();
    command_generator.GenerateSubMixCommands();
@@ -712,11 +714,16 @@ u64 System::GenerateCommand(std::span<u8> in_command_buffer,
            render_context.behavior->IsAudioRendererProcessingTimeLimit70PercentSupported();
            time_limit_percent = 70.0f;
        }
+
+        const auto end_estimated_time{drop_voice_param *
+                                      static_cast<f32>(command_buffer.estimated_process_time)};
+        const auto estimated_time{start_estimated_time - end_estimated_time};
+
        const auto time_limit{static_cast<u32>(
-            static_cast<f32>(start_estimated_time - command_buffer.estimated_process_time) +
-            (((time_limit_percent / 100.0f) * 2'880'000.0) *
-             (static_cast<f32>(render_time_limit_percent) / 100.0f)))};
-        num_voices_dropped = DropVoices(command_buffer, start_estimated_time, time_limit);
+            estimated_time + (((time_limit_percent / 100.0f) * 2'880'000.0) *
+                              (static_cast<f32>(render_time_limit_percent) / 100.0f)))};
+        num_voices_dropped =
+            DropVoices(command_buffer, static_cast<u32>(start_estimated_time), time_limit);
    }

    command_list_header->buffer_size = command_buffer.size;
@@ -737,24 +744,33 @@ u64 System::GenerateCommand(std::span<u8> in_command_buffer,
    return command_buffer.size;
 }

-u32 System::DropVoices(CommandBuffer& command_buffer, const u32 estimated_process_time,
-                       const u32 time_limit) {
+f32 System::GetVoiceDropParameter() const {
+    return drop_voice_param;
+}
+
+void System::SetVoiceDropParameter(f32 voice_drop_) {
+    drop_voice_param = voice_drop_;
+}
+
+u32 System::DropVoices(CommandBuffer& command_buffer, u32 estimated_process_time, u32 time_limit) {
    u32 i{0};
    auto command_list{command_buffer.command_list.data() + sizeof(CommandListHeader)};
-    ICommand* cmd{};
+    ICommand* cmd{nullptr};

-    for (; i < command_buffer.count; i++) {
+    // Find a first valid voice to drop
+    while (i < command_buffer.count) {
        cmd = reinterpret_cast<ICommand*>(command_list);
-        if (cmd->type != CommandId::Performance &&
-            cmd->type != CommandId::DataSourcePcmInt16Version1 &&
-            cmd->type != CommandId::DataSourcePcmInt16Version2 &&
-            cmd->type != CommandId::DataSourcePcmFloatVersion1 &&
-            cmd->type != CommandId::DataSourcePcmFloatVersion2 &&
-            cmd->type != CommandId::DataSourceAdpcmVersion1 &&
-            cmd->type != CommandId::DataSourceAdpcmVersion2) {
+        if (cmd->type == CommandId::Performance ||
+            cmd->type == CommandId::DataSourcePcmInt16Version1 ||
+            cmd->type == CommandId::DataSourcePcmInt16Version2 ||
+            cmd->type == CommandId::DataSourcePcmFloatVersion1 ||
+            cmd->type == CommandId::DataSourcePcmFloatVersion2 ||
+            cmd->type == CommandId::DataSourceAdpcmVersion1 ||
+            cmd->type == CommandId::DataSourceAdpcmVersion2) {
            break;
        }
        command_list += cmd->size;
+        i++;
    }

    if (cmd == nullptr || command_buffer.count == 0 || i >= command_buffer.count) {
@@ -767,6 +783,7 @@ u32 System::DropVoices(CommandBuffer& command_buffer, const u32 estimated_proces
        const auto node_id_type{cmd->node_id >> 28};
        const auto node_id_base{cmd->node_id & 0xFFF};

+        // If the new estimated process time falls below the limit, we're done dropping.
        if (estimated_process_time <= time_limit) {
            break;
        }
@@ -775,6 +792,7 @@ u32 System::DropVoices(CommandBuffer& command_buffer, const u32 estimated_proces
            break;
        }

+        // Don't drop voices marked with the highest priority.
        auto& voice_info{voice_context.GetInfo(node_id_base)};
        if (voice_info.priority == HighestVoicePriority) {
            break;
@@ -783,18 +801,23 @@ u32 System::DropVoices(CommandBuffer& command_buffer, const u32 estimated_proces
        voices_dropped++;
        voice_info.voice_dropped = true;

-        if (i < command_buffer.count) {
-            while (cmd->node_id == node_id) {
-                if (cmd->type == CommandId::DepopPrepare) {
-                    cmd->enabled = true;
-                } else if (cmd->type == CommandId::Performance || !cmd->enabled) {
-                    cmd->enabled = false;
-                }
-                i++;
-                command_list += cmd->size;
-                cmd = reinterpret_cast<ICommand*>(command_list);
+        // First iteration should drop the voice, and then iterate through all of the commands tied
+        // to the voice. We don't need reverb on a voice which we've just removed, for example.
+        // Depops can't be removed otherwise we'll introduce audio popping, and we don't
+        // remove perf commands. Lower the estimated time for each command dropped.
+        while (i < command_buffer.count && cmd->node_id == node_id) {
+            if (cmd->type == CommandId::DepopPrepare) {
+                cmd->enabled = true;
+            } else if (cmd->enabled && cmd->type != CommandId::Performance) {
+                cmd->enabled = false;
+                estimated_process_time -= static_cast<u32>(
+                    drop_voice_param * static_cast<f32>(cmd->estimated_process_time));
            }
+            command_list += cmd->size;
+            cmd = reinterpret_cast<ICommand*>(command_list);
+            i++;
        }
+        i++;
    }
    return voices_dropped;
 }
@@ -196,6 +196,20 @@ public:
     */
    u32 DropVoices(CommandBuffer& command_buffer, u32 estimated_process_time, u32 time_limit);

+    /**
+     * Get the current voice drop parameter.
+     *
+     * @return The current voice drop.
+     */
+    f32 GetVoiceDropParameter() const;
+
+    /**
+     * Set the voice drop parameter.
+     *
+     * @param The new voice drop.
+     */
+    void SetVoiceDropParameter(f32 voice_drop);
+
 private:
    /// Core system
    Core::System& core;
@@ -301,6 +315,8 @@ private:
    u32 num_voices_dropped{};
    /// Tick that rendering started
    u64 render_start_tick{};
+    /// Parameter to control the threshold for dropping voices if the audio graph gets too large
+    f32 drop_voice_param{1.0f};
 };

 } // namespace AudioRenderer
@@ -94,7 +94,7 @@ bool SystemManager::Remove(System& system_) {
 }

 void SystemManager::ThreadFunc() {
-    constexpr char name[]{"yuzu:AudioRenderSystemManager"};
+    constexpr char name[]{"AudioRenderSystemManager"};
    MicroProfileOnThreadCreate(name);
    Common::SetCurrentThreadName(name);
    Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
@@ -74,8 +74,8 @@ void VoiceContext::SortInfo() {
    }

    std::ranges::sort(sorted_voice_info, [](const VoiceInfo* a, const VoiceInfo* b) {
-        return a->priority != b->priority ? a->priority < b->priority
-                                          : a->sort_order < b->sort_order;
+        return a->priority != b->priority ? a->priority > b->priority
+                                          : a->sort_order > b->sort_order;
    });
 }

@@ -66,10 +66,10 @@ public:
        const auto latency_error = cubeb_get_min_latency(ctx, &params, &minimum_latency);
        if (latency_error != CUBEB_OK) {
            LOG_CRITICAL(Audio_Sink, "Error getting minimum latency, error: {}", latency_error);
-            minimum_latency = 256U;
+            minimum_latency = TargetSampleCount * 2;
        }

-        minimum_latency = std::max(minimum_latency, 256u);
+        minimum_latency = std::max(minimum_latency, TargetSampleCount * 2);

        LOG_INFO(Service_Audio,
                 "Opening cubeb stream {} type {} with: rate {} channels {} (system channels {}) "
@@ -326,4 +326,31 @@ std::vector<std::string> ListCubebSinkDevices(bool capture) {
    return device_list;
 }

+u32 GetCubebLatency() {
+    cubeb* ctx;
+
+    if (cubeb_init(&ctx, "yuzu Latency Getter", nullptr) != CUBEB_OK) {
+        LOG_CRITICAL(Audio_Sink, "cubeb_init failed");
+        // Return a large latency so we choose SDL instead.
+        return 10000u;
+    }
+
+    cubeb_stream_params params{};
+    params.rate = TargetSampleRate;
+    params.channels = 2;
+    params.format = CUBEB_SAMPLE_S16LE;
+    params.prefs = CUBEB_STREAM_PREF_NONE;
+    params.layout = CUBEB_LAYOUT_STEREO;
+
+    u32 latency{0};
+    const auto latency_error = cubeb_get_min_latency(ctx, &params, &latency);
+    if (latency_error != CUBEB_OK) {
+        LOG_CRITICAL(Audio_Sink, "Error getting minimum latency, error: {}", latency_error);
+        latency = TargetSampleCount * 2;
+    }
+    latency = std::max(latency, TargetSampleCount * 2);
+    cubeb_destroy(ctx);
+    return latency;
+}
+
 } // namespace AudioCore::Sink
@@ -96,4 +96,11 @@ private:
 */
 std::vector<std::string> ListCubebSinkDevices(bool capture);

+/**
+ * Get the reported latency for this sink.
+ *
+ * @return Minimum latency for this sink.
+ */
+u32 GetCubebLatency();
+
 } // namespace AudioCore::Sink
@@ -47,11 +47,7 @@ public:
        spec.freq = TargetSampleRate;
        spec.channels = static_cast<u8>(device_channels);
        spec.format = AUDIO_S16SYS;
-        if (type == StreamType::Render) {
-            spec.samples = TargetSampleCount;
-        } else {
-            spec.samples = 1024;
-        }
+        spec.samples = TargetSampleCount * 2;
        spec.callback = &SDLSinkStream::DataCallback;
        spec.userdata = this;

@@ -234,10 +230,16 @@ std::vector<std::string> ListSDLSinkDevices(bool capture) {

    const int device_count = SDL_GetNumAudioDevices(capture);
    for (int i = 0; i < device_count; ++i) {
-        device_list.emplace_back(SDL_GetAudioDeviceName(i, 0));
+        if (const char* name = SDL_GetAudioDeviceName(i, capture)) {
+            device_list.emplace_back(name);
+        }
    }

    return device_list;
 }

+u32 GetSDLLatency() {
+    return TargetSampleCount * 2;
+}
+
 } // namespace AudioCore::Sink
@@ -87,4 +87,11 @@ private:
 */
 std::vector<std::string> ListSDLSinkDevices(bool capture);

+/**
+ * Get the reported latency for this sink.
+ *
+ * @return Minimum latency for this sink.
+ */
+u32 GetSDLLatency();
+
 } // namespace AudioCore::Sink
@@ -21,58 +21,80 @@ namespace {
 struct SinkDetails {
    using FactoryFn = std::unique_ptr<Sink> (*)(std::string_view);
    using ListDevicesFn = std::vector<std::string> (*)(bool);
+    using LatencyFn = u32 (*)();

    /// Name for this sink.
-    const char* id;
+    std::string_view id;
    /// A method to call to construct an instance of this type of sink.
    FactoryFn factory;
    /// A method to call to list available devices.
    ListDevicesFn list_devices;
+    /// Method to get the latency of this backend.
+    LatencyFn latency;
 };

 // sink_details is ordered in terms of desirability, with the best choice at the top.
 constexpr SinkDetails sink_details[] = {
 #ifdef HAVE_CUBEB
-    SinkDetails{"cubeb",
-                [](std::string_view device_id) -> std::unique_ptr<Sink> {
-                    return std::make_unique<CubebSink>(device_id);
-                },
-                &ListCubebSinkDevices},
+    SinkDetails{
+        "cubeb",
+        [](std::string_view device_id) -> std::unique_ptr<Sink> {
+            return std::make_unique<CubebSink>(device_id);
+        },
+        &ListCubebSinkDevices,
+        &GetCubebLatency,
+    },
 #endif
 #ifdef HAVE_SDL2
-    SinkDetails{"sdl2",
-                [](std::string_view device_id) -> std::unique_ptr<Sink> {
-                    return std::make_unique<SDLSink>(device_id);
-                },
-                &ListSDLSinkDevices},
+    SinkDetails{
+        "sdl2",
+        [](std::string_view device_id) -> std::unique_ptr<Sink> {
+            return std::make_unique<SDLSink>(device_id);
+        },
+        &ListSDLSinkDevices,
+        &GetSDLLatency,
+    },
 #endif
    SinkDetails{"null",
                [](std::string_view device_id) -> std::unique_ptr<Sink> {
                    return std::make_unique<NullSink>(device_id);
                },
-                [](bool capture) { return std::vector<std::string>{"null"}; }},
+                [](bool capture) { return std::vector<std::string>{"null"}; }, []() { return 0u; }},
 };

 const SinkDetails& GetOutputSinkDetails(std::string_view sink_id) {
-    auto iter =
-        std::find_if(std::begin(sink_details), std::end(sink_details),
-                     [sink_id](const auto& sink_detail) { return sink_detail.id == sink_id; });
+    const auto find_backend{[](std::string_view id) {
+        return std::find_if(std::begin(sink_details), std::end(sink_details),
+                            [&id](const auto& sink_detail) { return sink_detail.id == id; });
+    }};

-    if (sink_id == "auto" || iter == std::end(sink_details)) {
-        if (sink_id != "auto") {
-            LOG_ERROR(Audio, "Invalid sink_id {}", sink_id);
+    auto iter = find_backend(sink_id);
+
+    if (sink_id == "auto") {
+        // Auto-select a backend. Prefer CubeB, but it may report a large minimum latency which
+        // causes audio issues, in that case go with SDL.
+#if defined(HAVE_CUBEB) && defined(HAVE_SDL2)
+        iter = find_backend("cubeb");
+        if (iter->latency() > TargetSampleCount * 3) {
+            iter = find_backend("sdl2");
        }
-        // Auto-select.
-        // sink_details is ordered in terms of desirability, with the best choice at the front.
+#else
        iter = std::begin(sink_details);
+#endif
+        LOG_INFO(Service_Audio, "Auto-selecting the {} backend", iter->id);
+    }
+
+    if (iter == std::end(sink_details)) {
+        LOG_ERROR(Audio, "Invalid sink_id {}", sink_id);
+        iter = find_backend("null");
    }

    return *iter;
 }
 } // Anonymous namespace

-std::vector<const char*> GetSinkIDs() {
-    std::vector<const char*> sink_ids(std::size(sink_details));
+std::vector<std::string_view> GetSinkIDs() {
+    std::vector<std::string_view> sink_ids(std::size(sink_details));

    std::transform(std::begin(sink_details), std::end(sink_details), std::begin(sink_ids),
                   [](const auto& sink) { return sink.id; });
@@ -19,7 +19,7 @@ class Sink;
 *
 * @return Vector of available sink names.
 */
-std::vector<const char*> GetSinkIDs();
+std::vector<std::string_view> GetSinkIDs();

 /**
 * Gets the list of devices for a particular sink identified by the given ID.
@@ -17,6 +17,8 @@ endif ()
 include(GenerateSCMRev)

 add_library(common STATIC
+    address_space.cpp
+    address_space.h
    algorithm.h
    alignment.h
    announce_multiplayer_room.h
@@ -81,6 +83,8 @@ add_library(common STATIC
    microprofile.cpp
    microprofile.h
    microprofileui.h
+    multi_level_page_table.cpp
+    multi_level_page_table.h
    nvidia_flags.cpp
    nvidia_flags.h
    page_table.cpp
@@ -152,12 +156,13 @@ if (MSVC)
  )
  target_compile_options(common PRIVATE
    /W4
-    /WX
+
+    /we4242 # 'identifier': conversion from 'type1' to 'type2', possible loss of data
+    /we4254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
+    /we4800 # Implicit conversion from 'type' to bool. Possible information loss
  )
 else()
  target_compile_options(common PRIVATE
-    -Werror
-
    $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>
  )
 endif()
@@ -165,7 +170,11 @@ endif()
 create_target_directory_groups(common)

 target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile Threads::Threads)
-target_link_libraries(common PRIVATE lz4::lz4)
+if (TARGET lz4::lz4)
+  target_link_libraries(common PRIVATE lz4::lz4)
+else()
+  target_link_libraries(common PRIVATE LZ4::lz4_shared)
+endif()
 if (TARGET zstd::zstd)
  target_link_libraries(common PRIVATE zstd::zstd)
 else()
@@ -0,0 +1,10 @@
+// SPDX-FileCopyrightText: 2021 Skyline Team and Contributors
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "common/address_space.inc"
+
+namespace Common {
+
+template class Common::FlatAllocator<u32, 0, 32>;
+
+}
@@ -0,0 +1,150 @@
+// SPDX-FileCopyrightText: 2021 Skyline Team and Contributors
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <concepts>
+#include <functional>
+#include <mutex>
+#include <vector>
+
+#include "common/common_types.h"
+
+namespace Common {
+template <typename VaType, size_t AddressSpaceBits>
+concept AddressSpaceValid = std::is_unsigned_v<VaType> && sizeof(VaType) * 8 >= AddressSpaceBits;
+
+struct EmptyStruct {};
+
+/**
+ * @brief FlatAddressSpaceMap provides a generic VA->PA mapping implementation using a sorted vector
+ */
+template <typename VaType, VaType UnmappedVa, typename PaType, PaType UnmappedPa,
+          bool PaContigSplit, size_t AddressSpaceBits, typename ExtraBlockInfo = EmptyStruct>
+requires AddressSpaceValid<VaType, AddressSpaceBits>
+class FlatAddressSpaceMap {
+public:
+    /// The maximum VA that this AS can technically reach
+    static constexpr VaType VaMaximum{(1ULL << (AddressSpaceBits - 1)) +
+                                      ((1ULL << (AddressSpaceBits - 1)) - 1)};
+
+    explicit FlatAddressSpaceMap(VaType va_limit,
+                                 std::function<void(VaType, VaType)> unmap_callback = {});
+
+    FlatAddressSpaceMap() = default;
+
+    void Map(VaType virt, PaType phys, VaType size, ExtraBlockInfo extra_info = {}) {
+        std::scoped_lock lock(block_mutex);
+        MapLocked(virt, phys, size, extra_info);
+    }
+
+    void Unmap(VaType virt, VaType size) {
+        std::scoped_lock lock(block_mutex);
+        UnmapLocked(virt, size);
+    }
+
+    VaType GetVALimit() const {
+        return va_limit;
+    }
+
+protected:
+    /**
+     * @brief Represents a block of memory in the AS, the physical mapping is contiguous until
+     * another block with a different phys address is hit
+     */
+    struct Block {
+        /// VA of the block
+        VaType virt{UnmappedVa};
+        /// PA of the block, will increase 1-1 with VA until a new block is encountered
+        PaType phys{UnmappedPa};
+        [[no_unique_address]] ExtraBlockInfo extra_info;
+
+        Block() = default;
+
+        Block(VaType virt_, PaType phys_, ExtraBlockInfo extra_info_)
+            : virt(virt_), phys(phys_), extra_info(extra_info_) {}
+
+        bool Valid() const {
+            return virt != UnmappedVa;
+        }
+
+        bool Mapped() const {
+            return phys != UnmappedPa;
+        }
+
+        bool Unmapped() const {
+            return phys == UnmappedPa;
+        }
+
+        bool operator<(const VaType& p_virt) const {
+            return virt < p_virt;
+        }
+    };
+
+    /**
+     * @brief Maps a PA range into the given AS region
+     * @note block_mutex MUST be locked when calling this
+     */
+    void MapLocked(VaType virt, PaType phys, VaType size, ExtraBlockInfo extra_info);
+
+    /**
+     * @brief Unmaps the given range and merges it with other unmapped regions
+     * @note block_mutex MUST be locked when calling this
+     */
+    void UnmapLocked(VaType virt, VaType size);
+
+    std::mutex block_mutex;
+    std::vector<Block> blocks{Block{}};
+
+    /// a soft limit on the maximum VA of the AS
+    VaType va_limit{VaMaximum};
+
+private:
+    /// Callback called when the mappings in an region have changed
+    std::function<void(VaType, VaType)> unmap_callback{};
+};
+
+/**
+ * @brief FlatMemoryManager specialises FlatAddressSpaceMap to work as an allocator, with an
+ * initial, fast linear pass and a subsequent slower pass that iterates until it finds a free block
+ */
+template <typename VaType, VaType UnmappedVa, size_t AddressSpaceBits>
+requires AddressSpaceValid<VaType, AddressSpaceBits>
+class FlatAllocator
+    : public FlatAddressSpaceMap<VaType, UnmappedVa, bool, false, false, AddressSpaceBits> {
+private:
+    using Base = FlatAddressSpaceMap<VaType, UnmappedVa, bool, false, false, AddressSpaceBits>;
+
+public:
+    explicit FlatAllocator(VaType virt_start, VaType va_limit = Base::VaMaximum);
+
+    /**
+     * @brief Allocates a region in the AS of the given size and returns its address
+     */
+    VaType Allocate(VaType size);
+
+    /**
+     * @brief Marks the given region in the AS as allocated
+     */
+    void AllocateFixed(VaType virt, VaType size);
+
+    /**
+     * @brief Frees an AS region so it can be used again
+     */
+    void Free(VaType virt, VaType size);
+
+    VaType GetVAStart() const {
+        return virt_start;
+    }
+
+private:
+    /// The base VA of the allocator, no allocations will be below this
+    VaType virt_start;
+
+    /**
+     * The end address for the initial linear allocation pass
+     * Once this reaches the AS limit the slower allocation path will be used
+     */
+    VaType current_linear_alloc_end;
+};
+} // namespace Common
@@ -0,0 +1,366 @@
+// SPDX-FileCopyrightText: 2021 Skyline Team and Contributors
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "common/address_space.h"
+#include "common/assert.h"
+
+#define MAP_MEMBER(returnType)                                                                     \
+    template <typename VaType, VaType UnmappedVa, typename PaType, PaType UnmappedPa,              \
+              bool PaContigSplit, size_t AddressSpaceBits, typename ExtraBlockInfo>                \
+    requires AddressSpaceValid<VaType, AddressSpaceBits> returnType FlatAddressSpaceMap<           \
+        VaType, UnmappedVa, PaType, UnmappedPa, PaContigSplit, AddressSpaceBits, ExtraBlockInfo>
+#define MAP_MEMBER_CONST()                                                                         \
+    template <typename VaType, VaType UnmappedVa, typename PaType, PaType UnmappedPa,              \
+              bool PaContigSplit, size_t AddressSpaceBits, typename ExtraBlockInfo>                \
+    requires AddressSpaceValid<VaType, AddressSpaceBits> FlatAddressSpaceMap<                      \
+        VaType, UnmappedVa, PaType, UnmappedPa, PaContigSplit, AddressSpaceBits, ExtraBlockInfo>
+
+#define MM_MEMBER(returnType)                                                                      \
+    template <typename VaType, VaType UnmappedVa, size_t AddressSpaceBits>                         \
+    requires AddressSpaceValid<VaType, AddressSpaceBits> returnType                                \
+        FlatMemoryManager<VaType, UnmappedVa, AddressSpaceBits>
+
+#define ALLOC_MEMBER(returnType)                                                                   \
+    template <typename VaType, VaType UnmappedVa, size_t AddressSpaceBits>                         \
+    requires AddressSpaceValid<VaType, AddressSpaceBits> returnType                                \
+        FlatAllocator<VaType, UnmappedVa, AddressSpaceBits>
+#define ALLOC_MEMBER_CONST()                                                                       \
+    template <typename VaType, VaType UnmappedVa, size_t AddressSpaceBits>                         \
+    requires AddressSpaceValid<VaType, AddressSpaceBits>                                           \
+        FlatAllocator<VaType, UnmappedVa, AddressSpaceBits>
+
+namespace Common {
+MAP_MEMBER_CONST()::FlatAddressSpaceMap(VaType va_limit_,
+                                        std::function<void(VaType, VaType)> unmap_callback_)
+    : va_limit{va_limit_}, unmap_callback{std::move(unmap_callback_)} {
+    if (va_limit > VaMaximum) {
+        ASSERT_MSG(false, "Invalid VA limit!");
+    }
+}
+
+MAP_MEMBER(void)::MapLocked(VaType virt, PaType phys, VaType size, ExtraBlockInfo extra_info) {
+    VaType virt_end{virt + size};
+
+    if (virt_end > va_limit) {
+        ASSERT_MSG(false,
+                   "Trying to map a block past the VA limit: virt_end: 0x{:X}, va_limit: 0x{:X}",
+                   virt_end, va_limit);
+    }
+
+    auto block_end_successor{std::lower_bound(blocks.begin(), blocks.end(), virt_end)};
+    if (block_end_successor == blocks.begin()) {
+        ASSERT_MSG(false, "Trying to map a block before the VA start: virt_end: 0x{:X}", virt_end);
+    }
+
+    auto block_end_predecessor{std::prev(block_end_successor)};
+
+    if (block_end_successor != blocks.end()) {
+        // We have blocks in front of us, if one is directly in front then we don't have to add a
+        // tail
+        if (block_end_successor->virt != virt_end) {
+            PaType tailPhys{[&]() -> PaType {
+                if constexpr (!PaContigSplit) {
+                    // Always propagate unmapped regions rather than calculating offset
+                    return block_end_predecessor->phys;
+                } else {
+                    if (block_end_predecessor->Unmapped()) {
+                        // Always propagate unmapped regions rather than calculating offset
+                        return block_end_predecessor->phys;
+                    } else {
+                        return block_end_predecessor->phys + virt_end - block_end_predecessor->virt;
+                    }
+                }
+            }()};
+
+            if (block_end_predecessor->virt >= virt) {
+                // If this block's start would be overlapped by the map then reuse it as a tail
+                // block
+                block_end_predecessor->virt = virt_end;
+                block_end_predecessor->phys = tailPhys;
+                block_end_predecessor->extra_info = block_end_predecessor->extra_info;
+
+                // No longer predecessor anymore
+                block_end_successor = block_end_predecessor--;
+            } else {
+                // Else insert a new one and we're done
+                blocks.insert(block_end_successor,
+                              {Block(virt, phys, extra_info),
+                               Block(virt_end, tailPhys, block_end_predecessor->extra_info)});
+                if (unmap_callback) {
+                    unmap_callback(virt, size);
+                }
+
+                return;
+            }
+        }
+    } else {
+        // block_end_predecessor will always be unmapped as blocks has to be terminated by an
+        // unmapped chunk
+        if (block_end_predecessor != blocks.begin() && block_end_predecessor->virt >= virt) {
+            // Move the unmapped block start backwards
+            block_end_predecessor->virt = virt_end;
+
+            // No longer predecessor anymore
+            block_end_successor = block_end_predecessor--;
+        } else {
+            // Else insert a new one and we're done
+            blocks.insert(block_end_successor,
+                          {Block(virt, phys, extra_info), Block(virt_end, UnmappedPa, {})});
+            if (unmap_callback) {
+                unmap_callback(virt, size);
+            }
+
+            return;
+        }
+    }
+
+    auto block_start_successor{block_end_successor};
+
+    // Walk the block vector to find the start successor as this is more efficient than another
+    // binary search in most scenarios
+    while (std::prev(block_start_successor)->virt >= virt) {
+        block_start_successor--;
+    }
+
+    // Check that the start successor is either the end block or something in between
+    if (block_start_successor->virt > virt_end) {
+        ASSERT_MSG(false, "Unsorted block in AS map: virt: 0x{:X}", block_start_successor->virt);
+    } else if (block_start_successor->virt == virt_end) {
+        // We need to create a new block as there are none spare that we would overwrite
+        blocks.insert(block_start_successor, Block(virt, phys, extra_info));
+    } else {
+        // Erase overwritten blocks
+        if (auto eraseStart{std::next(block_start_successor)}; eraseStart != block_end_successor) {
+            blocks.erase(eraseStart, block_end_successor);
+        }
+
+        // Reuse a block that would otherwise be overwritten as a start block
+        block_start_successor->virt = virt;
+        block_start_successor->phys = phys;
+        block_start_successor->extra_info = extra_info;
+    }
+
+    if (unmap_callback) {
+        unmap_callback(virt, size);
+    }
+}
+
+MAP_MEMBER(void)::UnmapLocked(VaType virt, VaType size) {
+    VaType virt_end{virt + size};
+
+    if (virt_end > va_limit) {
+        ASSERT_MSG(false,
+                   "Trying to map a block past the VA limit: virt_end: 0x{:X}, va_limit: 0x{:X}",
+                   virt_end, va_limit);
+    }
+
+    auto block_end_successor{std::lower_bound(blocks.begin(), blocks.end(), virt_end)};
+    if (block_end_successor == blocks.begin()) {
+        ASSERT_MSG(false, "Trying to unmap a block before the VA start: virt_end: 0x{:X}",
+                   virt_end);
+    }
+
+    auto block_end_predecessor{std::prev(block_end_successor)};
+
+    auto walk_back_to_predecessor{[&](auto iter) {
+        while (iter->virt >= virt) {
+            iter--;
+        }
+
+        return iter;
+    }};
+
+    auto erase_blocks_with_end_unmapped{[&](auto unmappedEnd) {
+        auto block_start_predecessor{walk_back_to_predecessor(unmappedEnd)};
+        auto block_start_successor{std::next(block_start_predecessor)};
+
+        auto eraseEnd{[&]() {
+            if (block_start_predecessor->Unmapped()) {
+                // If the start predecessor is unmapped then we can erase everything in our region
+                // and be done
+                return std::next(unmappedEnd);
+            } else {
+                // Else reuse the end predecessor as the start of our unmapped region then erase all
+                // up to it
+                unmappedEnd->virt = virt;
+                return unmappedEnd;
+            }
+        }()};
+
+        // We can't have two unmapped regions after each other
+        if (eraseEnd != blocks.end() &&
+            (eraseEnd == block_start_successor ||
+             (block_start_predecessor->Unmapped() && eraseEnd->Unmapped()))) {
+            ASSERT_MSG(false, "Multiple contiguous unmapped regions are unsupported!");
+        }
+
+        blocks.erase(block_start_successor, eraseEnd);
+    }};
+
+    // We can avoid any splitting logic if these are the case
+    if (block_end_predecessor->Unmapped()) {
+        if (block_end_predecessor->virt > virt) {
+            erase_blocks_with_end_unmapped(block_end_predecessor);
+        }
+
+        if (unmap_callback) {
+            unmap_callback(virt, size);
+        }
+
+        return; // The region is unmapped, bail out early
+    } else if (block_end_successor->virt == virt_end && block_end_successor->Unmapped()) {
+        erase_blocks_with_end_unmapped(block_end_successor);
+
+        if (unmap_callback) {
+            unmap_callback(virt, size);
+        }
+
+        return; // The region is unmapped here and doesn't need splitting, bail out early
+    } else if (block_end_successor == blocks.end()) {
+        // This should never happen as the end should always follow an unmapped block
+        ASSERT_MSG(false, "Unexpected Memory Manager state!");
+    } else if (block_end_successor->virt != virt_end) {
+        // If one block is directly in front then we don't have to add a tail
+
+        // The previous block is mapped so we will need to add a tail with an offset
+        PaType tailPhys{[&]() {
+            if constexpr (PaContigSplit) {
+                return block_end_predecessor->phys + virt_end - block_end_predecessor->virt;
+            } else {
+                return block_end_predecessor->phys;
+            }
+        }()};
+
+        if (block_end_predecessor->virt >= virt) {
+            // If this block's start would be overlapped by the unmap then reuse it as a tail block
+            block_end_predecessor->virt = virt_end;
+            block_end_predecessor->phys = tailPhys;
+
+            // No longer predecessor anymore
+            block_end_successor = block_end_predecessor--;
+        } else {
+            blocks.insert(block_end_successor,
+                          {Block(virt, UnmappedPa, {}),
+                           Block(virt_end, tailPhys, block_end_predecessor->extra_info)});
+            if (unmap_callback) {
+                unmap_callback(virt, size);
+            }
+
+            // The previous block is mapped and ends before
+            return;
+        }
+    }
+
+    // Walk the block vector to find the start predecessor as this is more efficient than another
+    // binary search in most scenarios
+    auto block_start_predecessor{walk_back_to_predecessor(block_end_successor)};
+    auto block_start_successor{std::next(block_start_predecessor)};
+
+    if (block_start_successor->virt > virt_end) {
+        ASSERT_MSG(false, "Unsorted block in AS map: virt: 0x{:X}", block_start_successor->virt);
+    } else if (block_start_successor->virt == virt_end) {
+        // There are no blocks between the start and the end that would let us skip inserting a new
+        // one for head
+
+        // The previous block is may be unmapped, if so we don't need to insert any unmaps after it
+        if (block_start_predecessor->Mapped()) {
+            blocks.insert(block_start_successor, Block(virt, UnmappedPa, {}));
+        }
+    } else if (block_start_predecessor->Unmapped()) {
+        // If the previous block is unmapped
+        blocks.erase(block_start_successor, block_end_predecessor);
+    } else {
+        // Erase overwritten blocks, skipping the first one as we have written the unmapped start
+        // block there
+        if (auto eraseStart{std::next(block_start_successor)}; eraseStart != block_end_successor) {
+            blocks.erase(eraseStart, block_end_successor);
+        }
+
+        // Add in the unmapped block header
+        block_start_successor->virt = virt;
+        block_start_successor->phys = UnmappedPa;
+    }
+
+    if (unmap_callback)
+        unmap_callback(virt, size);
+}
+
+ALLOC_MEMBER_CONST()::FlatAllocator(VaType virt_start_, VaType va_limit_)
+    : Base{va_limit_}, virt_start{virt_start_}, current_linear_alloc_end{virt_start_} {}
+
+ALLOC_MEMBER(VaType)::Allocate(VaType size) {
+    std::scoped_lock lock(this->block_mutex);
+
+    VaType alloc_start{UnmappedVa};
+    VaType alloc_end{current_linear_alloc_end + size};
+
+    // Avoid searching backwards in the address space if possible
+    if (alloc_end >= current_linear_alloc_end && alloc_end <= this->va_limit) {
+        auto alloc_end_successor{
+            std::lower_bound(this->blocks.begin(), this->blocks.end(), alloc_end)};
+        if (alloc_end_successor == this->blocks.begin()) {
+            ASSERT_MSG(false, "First block in AS map is invalid!");
+        }
+
+        auto alloc_end_predecessor{std::prev(alloc_end_successor)};
+        if (alloc_end_predecessor->virt <= current_linear_alloc_end) {
+            alloc_start = current_linear_alloc_end;
+        } else {
+            // Skip over fixed any mappings in front of us
+            while (alloc_end_successor != this->blocks.end()) {
+                if (alloc_end_successor->virt - alloc_end_predecessor->virt < size ||
+                    alloc_end_predecessor->Mapped()) {
+                    alloc_start = alloc_end_predecessor->virt;
+                    break;
+                }
+
+                alloc_end_predecessor = alloc_end_successor++;
+
+                // Use the VA limit to calculate if we can fit in the final block since it has no
+                // successor
+                if (alloc_end_successor == this->blocks.end()) {
+                    alloc_end = alloc_end_predecessor->virt + size;
+
+                    if (alloc_end >= alloc_end_predecessor->virt && alloc_end <= this->va_limit) {
+                        alloc_start = alloc_end_predecessor->virt;
+                    }
+                }
+            }
+        }
+    }
+
+    if (alloc_start != UnmappedVa) {
+        current_linear_alloc_end = alloc_start + size;
+    } else { // If linear allocation overflows the AS then find a gap
+        if (this->blocks.size() <= 2) {
+            ASSERT_MSG(false, "Unexpected allocator state!");
+        }
+
+        auto search_predecessor{this->blocks.begin()};
+        auto search_successor{std::next(search_predecessor)};
+
+        while (search_successor != this->blocks.end() &&
+               (search_successor->virt - search_predecessor->virt < size ||
+                search_predecessor->Mapped())) {
+            search_predecessor = search_successor++;
+        }
+
+        if (search_successor != this->blocks.end()) {
+            alloc_start = search_predecessor->virt;
+        } else {
+            return {}; // AS is full
+        }
+    }
+
+    this->MapLocked(alloc_start, true, size, {});
+    return alloc_start;
+}
+
+ALLOC_MEMBER(void)::AllocateFixed(VaType virt, VaType size) {
+    this->Map(virt, true, size);
+}
+
+ALLOC_MEMBER(void)::Free(VaType virt, VaType size) {
+    this->Unmap(virt, size);
+}
+} // namespace Common
@@ -24,4 +24,12 @@ template <class ForwardIt, class T, class Compare = std::less<>>
    return first != last && !comp(value, *first) ? first : last;
 }

+template <typename T, typename Func, typename... Args>
+T FoldRight(T initial_value, Func&& func, Args&&... args) {
+    T value{initial_value};
+    const auto high_func = [&value, &func]<typename U>(U x) { value = func(value, x); };
+    (std::invoke(high_func, std::forward<Args>(args)), ...);
+    return value;
+}
+
 } // namespace Common
@@ -141,10 +141,6 @@ public:
    constexpr BitField(BitField&&) noexcept = default;
    constexpr BitField& operator=(BitField&&) noexcept = default;

-    [[nodiscard]] constexpr operator T() const {
-        return Value();
-    }
-
    constexpr void Assign(const T& value) {
 #ifdef _MSC_VER
        storage = static_cast<StorageType>((storage & ~mask) | FormatValue(value));
@@ -162,6 +158,17 @@ public:
        return ExtractValue(storage);
    }

+    template <typename ConvertedToType>
+    [[nodiscard]] constexpr ConvertedToType As() const {
+        static_assert(!std::is_same_v<T, ConvertedToType>,
+                      "Unnecessary cast. Use Value() instead.");
+        return static_cast<ConvertedToType>(Value());
+    }
+
+    [[nodiscard]] constexpr operator T() const {
+        return Value();
+    }
+
    [[nodiscard]] constexpr explicit operator bool() const {
        return Value() != 0;
    }
@@ -21,11 +21,6 @@ constexpr size_t hardware_interference_size = std::hardware_destructive_interfer
 constexpr size_t hardware_interference_size = 64;
 #endif

-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4324)
-#endif
-
 template <typename T, size_t capacity = 0x400>
 class MPSCQueue {
 public:
@@ -160,8 +155,4 @@ private:
    static_assert(std::is_nothrow_destructible_v<T>, "T must be nothrow destructible");
 };

-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
 } // namespace Common
@@ -3,24 +3,14 @@

 #pragma once

+#include <iterator>
 #include <type_traits>

 namespace Common {

-// Check if type is like an STL container
+// Check if type satisfies the ContiguousContainer named requirement.
 template <typename T>
-concept IsSTLContainer = requires(T t) {
-    typename T::value_type;
-    typename T::iterator;
-    typename T::const_iterator;
-    // TODO(ogniK): Replace below is std::same_as<void> when MSVC supports it.
-    t.begin();
-    t.end();
-    t.cbegin();
-    t.cend();
-    t.data();
-    t.size();
-};
+concept IsContiguousContainer = std::contiguous_iterator<typename T::iterator>;

 // TODO: Replace with std::derived_from when the <concepts> header
 //       is available on all supported platforms.
@@ -34,4 +24,12 @@ concept DerivedFrom = requires {
 template <typename From, typename To>
 concept ConvertibleTo = std::is_convertible_v<From, To>;

+// No equivalents in the stdlib
+
+template <typename T>
+concept IsArithmetic = std::is_arithmetic_v<T>;
+
+template <typename T>
+concept IsIntegral = std::is_integral_v<T>;
+
 } // namespace Common
@@ -4,14 +4,7 @@
 // From: https://github.com/eteran/cpp-utilities/blob/master/fixed/include/cpp-utilities/fixed.h
 // See also: http://stackoverflow.com/questions/79677/whats-the-best-way-to-do-fixed-point-math

-#ifndef FIXED_H_
-#define FIXED_H_
-
-#if __cplusplus >= 201402L
-#define CONSTEXPR14 constexpr
-#else
-#define CONSTEXPR14
-#endif
+#pragma once

 #include <cstddef> // for size_t
 #include <cstdint>
@@ -19,6 +12,8 @@
 #include <ostream>
 #include <type_traits>

+#include <common/concepts.h>
+
 namespace Common {

 template <size_t I, size_t F>
@@ -57,8 +52,8 @@ struct type_from_size<64> {
    static constexpr size_t size = 64;

    using value_type = int64_t;
-    using unsigned_type = std::make_unsigned<value_type>::type;
-    using signed_type = std::make_signed<value_type>::type;
+    using unsigned_type = std::make_unsigned_t<value_type>;
+    using signed_type = std::make_signed_t<value_type>;
    using next_size = type_from_size<128>;
 };

@@ -68,8 +63,8 @@ struct type_from_size<32> {
    static constexpr size_t size = 32;

    using value_type = int32_t;
-    using unsigned_type = std::make_unsigned<value_type>::type;
-    using signed_type = std::make_signed<value_type>::type;
+    using unsigned_type = std::make_unsigned_t<value_type>;
+    using signed_type = std::make_signed_t<value_type>;
    using next_size = type_from_size<64>;
 };

@@ -79,8 +74,8 @@ struct type_from_size<16> {
    static constexpr size_t size = 16;

    using value_type = int16_t;
-    using unsigned_type = std::make_unsigned<value_type>::type;
-    using signed_type = std::make_signed<value_type>::type;
+    using unsigned_type = std::make_unsigned_t<value_type>;
+    using signed_type = std::make_signed_t<value_type>;
    using next_size = type_from_size<32>;
 };

@@ -90,8 +85,8 @@ struct type_from_size<8> {
    static constexpr size_t size = 8;

    using value_type = int8_t;
-    using unsigned_type = std::make_unsigned<value_type>::type;
-    using signed_type = std::make_signed<value_type>::type;
+    using unsigned_type = std::make_unsigned_t<value_type>;
+    using signed_type = std::make_signed_t<value_type>;
    using next_size = type_from_size<16>;
 };

@@ -106,9 +101,9 @@ constexpr B next_to_base(N rhs) {
 struct divide_by_zero : std::exception {};

 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> divide(
+constexpr FixedPoint<I, F> divide(
    FixedPoint<I, F> numerator, FixedPoint<I, F> denominator, FixedPoint<I, F>& remainder,
-    typename std::enable_if<type_from_size<I + F>::next_size::is_specialized>::type* = nullptr) {
+    std::enable_if_t<type_from_size<I + F>::next_size::is_specialized>* = nullptr) {

    using next_type = typename FixedPoint<I, F>::next_type;
    using base_type = typename FixedPoint<I, F>::base_type;
@@ -126,9 +121,9 @@ CONSTEXPR14 FixedPoint<I, F> divide(
 }

 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> divide(
+constexpr FixedPoint<I, F> divide(
    FixedPoint<I, F> numerator, FixedPoint<I, F> denominator, FixedPoint<I, F>& remainder,
-    typename std::enable_if<!type_from_size<I + F>::next_size::is_specialized>::type* = nullptr) {
+    std::enable_if_t<!type_from_size<I + F>::next_size::is_specialized>* = nullptr) {

    using unsigned_type = typename FixedPoint<I, F>::unsigned_type;

@@ -196,9 +191,9 @@ CONSTEXPR14 FixedPoint<I, F> divide(

 // this is the usual implementation of multiplication
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> multiply(
+constexpr FixedPoint<I, F> multiply(
    FixedPoint<I, F> lhs, FixedPoint<I, F> rhs,
-    typename std::enable_if<type_from_size<I + F>::next_size::is_specialized>::type* = nullptr) {
+    std::enable_if_t<type_from_size<I + F>::next_size::is_specialized>* = nullptr) {

    using next_type = typename FixedPoint<I, F>::next_type;
    using base_type = typename FixedPoint<I, F>::base_type;
@@ -215,9 +210,9 @@ CONSTEXPR14 FixedPoint<I, F> multiply(
 // it is slightly slower, but is more robust since it doesn't
 // require and upgraded type
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> multiply(
+constexpr FixedPoint<I, F> multiply(
    FixedPoint<I, F> lhs, FixedPoint<I, F> rhs,
-    typename std::enable_if<!type_from_size<I + F>::next_size::is_specialized>::type* = nullptr) {
+    std::enable_if_t<!type_from_size<I + F>::next_size::is_specialized>* = nullptr) {

    using base_type = typename FixedPoint<I, F>::base_type;

@@ -272,19 +267,20 @@ public:
    static constexpr base_type one = base_type(1) << fractional_bits;

 public: // constructors
-    FixedPoint() = default;
-    FixedPoint(const FixedPoint&) = default;
-    FixedPoint(FixedPoint&&) = default;
-    FixedPoint& operator=(const FixedPoint&) = default;
+    constexpr FixedPoint() = default;

-    template <class Number>
-    constexpr FixedPoint(
-        Number n, typename std::enable_if<std::is_arithmetic<Number>::value>::type* = nullptr)
-        : data_(static_cast<base_type>(n * one)) {}
+    constexpr FixedPoint(const FixedPoint&) = default;
+    constexpr FixedPoint& operator=(const FixedPoint&) = default;
+
+    constexpr FixedPoint(FixedPoint&&) noexcept = default;
+    constexpr FixedPoint& operator=(FixedPoint&&) noexcept = default;
+
+    template <IsArithmetic Number>
+    constexpr FixedPoint(Number n) : data_(static_cast<base_type>(n * one)) {}

 public: // conversion
    template <size_t I2, size_t F2>
-    CONSTEXPR14 explicit FixedPoint(FixedPoint<I2, F2> other) {
+    constexpr explicit FixedPoint(FixedPoint<I2, F2> other) {
        static_assert(I2 <= I && F2 <= F, "Scaling conversion can only upgrade types");
        using T = FixedPoint<I2, F2>;

@@ -308,36 +304,14 @@ public:
    }

 public: // comparison operators
-    constexpr bool operator==(FixedPoint rhs) const {
-        return data_ == rhs.data_;
-    }
-
-    constexpr bool operator!=(FixedPoint rhs) const {
-        return data_ != rhs.data_;
-    }
-
-    constexpr bool operator<(FixedPoint rhs) const {
-        return data_ < rhs.data_;
-    }
-
-    constexpr bool operator>(FixedPoint rhs) const {
-        return data_ > rhs.data_;
-    }
-
-    constexpr bool operator<=(FixedPoint rhs) const {
-        return data_ <= rhs.data_;
-    }
-
-    constexpr bool operator>=(FixedPoint rhs) const {
-        return data_ >= rhs.data_;
-    }
+    friend constexpr auto operator<=>(FixedPoint lhs, FixedPoint rhs) = default;

 public: // unary operators
-    constexpr bool operator!() const {
+    [[nodiscard]] constexpr bool operator!() const {
        return !data_;
    }

-    constexpr FixedPoint operator~() const {
+    [[nodiscard]] constexpr FixedPoint operator~() const {
        // NOTE(eteran): this will often appear to "just negate" the value
        // that is not an error, it is because -x == (~x+1)
        // and that "+1" is adding an infinitesimally small fraction to the
@@ -345,89 +319,87 @@ public: // unary operators
        return FixedPoint::from_base(~data_);
    }

-    constexpr FixedPoint operator-() const {
+    [[nodiscard]] constexpr FixedPoint operator-() const {
        return FixedPoint::from_base(-data_);
    }

-    constexpr FixedPoint operator+() const {
+    [[nodiscard]] constexpr FixedPoint operator+() const {
        return FixedPoint::from_base(+data_);
    }

-    CONSTEXPR14 FixedPoint& operator++() {
+    constexpr FixedPoint& operator++() {
        data_ += one;
        return *this;
    }

-    CONSTEXPR14 FixedPoint& operator--() {
+    constexpr FixedPoint& operator--() {
        data_ -= one;
        return *this;
    }

-    CONSTEXPR14 FixedPoint operator++(int) {
+    constexpr FixedPoint operator++(int) {
        FixedPoint tmp(*this);
        data_ += one;
        return tmp;
    }

-    CONSTEXPR14 FixedPoint operator--(int) {
+    constexpr FixedPoint operator--(int) {
        FixedPoint tmp(*this);
        data_ -= one;
        return tmp;
    }

 public: // basic math operators
-    CONSTEXPR14 FixedPoint& operator+=(FixedPoint n) {
+    constexpr FixedPoint& operator+=(FixedPoint n) {
        data_ += n.data_;
        return *this;
    }

-    CONSTEXPR14 FixedPoint& operator-=(FixedPoint n) {
+    constexpr FixedPoint& operator-=(FixedPoint n) {
        data_ -= n.data_;
        return *this;
    }

-    CONSTEXPR14 FixedPoint& operator*=(FixedPoint n) {
+    constexpr FixedPoint& operator*=(FixedPoint n) {
        return assign(detail::multiply(*this, n));
    }

-    CONSTEXPR14 FixedPoint& operator/=(FixedPoint n) {
+    constexpr FixedPoint& operator/=(FixedPoint n) {
        FixedPoint temp;
        return assign(detail::divide(*this, n, temp));
    }

 private:
-    CONSTEXPR14 FixedPoint& assign(FixedPoint rhs) {
+    constexpr FixedPoint& assign(FixedPoint rhs) {
        data_ = rhs.data_;
        return *this;
    }

 public: // binary math operators, effects underlying bit pattern since these
        // don't really typically make sense for non-integer values
-    CONSTEXPR14 FixedPoint& operator&=(FixedPoint n) {
+    constexpr FixedPoint& operator&=(FixedPoint n) {
        data_ &= n.data_;
        return *this;
    }

-    CONSTEXPR14 FixedPoint& operator|=(FixedPoint n) {
+    constexpr FixedPoint& operator|=(FixedPoint n) {
        data_ |= n.data_;
        return *this;
    }

-    CONSTEXPR14 FixedPoint& operator^=(FixedPoint n) {
+    constexpr FixedPoint& operator^=(FixedPoint n) {
        data_ ^= n.data_;
        return *this;
    }

-    template <class Integer,
-              class = typename std::enable_if<std::is_integral<Integer>::value>::type>
-    CONSTEXPR14 FixedPoint& operator>>=(Integer n) {
+    template <IsIntegral Integer>
+    constexpr FixedPoint& operator>>=(Integer n) {
        data_ >>= n;
        return *this;
    }

-    template <class Integer,
-              class = typename std::enable_if<std::is_integral<Integer>::value>::type>
-    CONSTEXPR14 FixedPoint& operator<<=(Integer n) {
+    template <IsIntegral Integer>
+    constexpr FixedPoint& operator<<=(Integer n) {
        data_ <<= n;
        return *this;
    }
@@ -437,42 +409,42 @@ public: // conversion to basic types
        data_ += (data_ & fractional_mask) >> 1;
    }

-    constexpr int to_int() {
+    [[nodiscard]] constexpr int to_int() {
        round_up();
        return static_cast<int>((data_ & integer_mask) >> fractional_bits);
    }

-    constexpr unsigned int to_uint() const {
+    [[nodiscard]] constexpr unsigned int to_uint() {
        round_up();
        return static_cast<unsigned int>((data_ & integer_mask) >> fractional_bits);
    }

-    constexpr int64_t to_long() {
+    [[nodiscard]] constexpr int64_t to_long() {
        round_up();
        return static_cast<int64_t>((data_ & integer_mask) >> fractional_bits);
    }

-    constexpr int to_int_floor() const {
+    [[nodiscard]] constexpr int to_int_floor() const {
        return static_cast<int>((data_ & integer_mask) >> fractional_bits);
    }

-    constexpr int64_t to_long_floor() {
+    [[nodiscard]] constexpr int64_t to_long_floor() const {
        return static_cast<int64_t>((data_ & integer_mask) >> fractional_bits);
    }

-    constexpr unsigned int to_uint_floor() const {
+    [[nodiscard]] constexpr unsigned int to_uint_floor() const {
        return static_cast<unsigned int>((data_ & integer_mask) >> fractional_bits);
    }

-    constexpr float to_float() const {
+    [[nodiscard]] constexpr float to_float() const {
        return static_cast<float>(data_) / FixedPoint::one;
    }

-    constexpr double to_double() const {
+    [[nodiscard]] constexpr double to_double() const {
        return static_cast<double>(data_) / FixedPoint::one;
    }

-    constexpr base_type to_raw() const {
+    [[nodiscard]] constexpr base_type to_raw() const {
        return data_;
    }

@@ -480,27 +452,27 @@ public: // conversion to basic types
        data_ &= fractional_mask;
    }

-    constexpr base_type get_frac() const {
+    [[nodiscard]] constexpr base_type get_frac() const {
        return data_ & fractional_mask;
    }

 public:
-    CONSTEXPR14 void swap(FixedPoint& rhs) {
+    constexpr void swap(FixedPoint& rhs) noexcept {
        using std::swap;
        swap(data_, rhs.data_);
    }

 public:
-    base_type data_;
+    base_type data_{};
 };

 // if we have the same fractional portion, but differing integer portions, we trivially upgrade the
 // smaller type
 template <size_t I1, size_t I2, size_t F>
-CONSTEXPR14 typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type
-operator+(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
+constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> operator+(
+    FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {

-    using T = typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type;
+    using T = std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>;

    const T l = T::from_base(lhs.to_raw());
    const T r = T::from_base(rhs.to_raw());
@@ -508,10 +480,10 @@ operator+(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 }

 template <size_t I1, size_t I2, size_t F>
-CONSTEXPR14 typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type
-operator-(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
+constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> operator-(
+    FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {

-    using T = typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type;
+    using T = std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>;

    const T l = T::from_base(lhs.to_raw());
    const T r = T::from_base(rhs.to_raw());
@@ -519,10 +491,10 @@ operator-(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 }

 template <size_t I1, size_t I2, size_t F>
-CONSTEXPR14 typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type
-operator*(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
+constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> operator*(
+    FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {

-    using T = typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type;
+    using T = std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>;

    const T l = T::from_base(lhs.to_raw());
    const T r = T::from_base(rhs.to_raw());
@@ -530,10 +502,10 @@ operator*(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
 }

 template <size_t I1, size_t I2, size_t F>
-CONSTEXPR14 typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type
-operator/(FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {
+constexpr std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>> operator/(
+    FixedPoint<I1, F> lhs, FixedPoint<I2, F> rhs) {

-    using T = typename std::conditional<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>::type;
+    using T = std::conditional_t<I1 >= I2, FixedPoint<I1, F>, FixedPoint<I2, F>>;

    const T l = T::from_base(lhs.to_raw());
    const T r = T::from_base(rhs.to_raw());
@@ -548,159 +520,133 @@ std::ostream& operator<<(std::ostream& os, FixedPoint<I, F> f) {

 // basic math operators
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> operator+(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
+constexpr FixedPoint<I, F> operator+(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
    lhs += rhs;
    return lhs;
 }
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> operator-(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
+constexpr FixedPoint<I, F> operator-(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
    lhs -= rhs;
    return lhs;
 }
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> operator*(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
+constexpr FixedPoint<I, F> operator*(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
    lhs *= rhs;
    return lhs;
 }
 template <size_t I, size_t F>
-CONSTEXPR14 FixedPoint<I, F> operator/(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
+constexpr FixedPoint<I, F> operator/(FixedPoint<I, F> lhs, FixedPoint<I, F> rhs) {
    lhs /= rhs;
    return lhs;
 }

-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator+(FixedPoint<I, F> lhs, Number rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator+(FixedPoint<I, F> lhs, Number rhs) {
    lhs += FixedPoint<I, F>(rhs);
    return lhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator-(FixedPoint<I, F> lhs, Number rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator-(FixedPoint<I, F> lhs, Number rhs) {
    lhs -= FixedPoint<I, F>(rhs);
    return lhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator*(FixedPoint<I, F> lhs, Number rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator*(FixedPoint<I, F> lhs, Number rhs) {
    lhs *= FixedPoint<I, F>(rhs);
    return lhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator/(FixedPoint<I, F> lhs, Number rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator/(FixedPoint<I, F> lhs, Number rhs) {
    lhs /= FixedPoint<I, F>(rhs);
    return lhs;
 }

-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator+(Number lhs, FixedPoint<I, F> rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator+(Number lhs, FixedPoint<I, F> rhs) {
    FixedPoint<I, F> tmp(lhs);
    tmp += rhs;
    return tmp;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator-(Number lhs, FixedPoint<I, F> rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator-(Number lhs, FixedPoint<I, F> rhs) {
    FixedPoint<I, F> tmp(lhs);
    tmp -= rhs;
    return tmp;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator*(Number lhs, FixedPoint<I, F> rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator*(Number lhs, FixedPoint<I, F> rhs) {
    FixedPoint<I, F> tmp(lhs);
    tmp *= rhs;
    return tmp;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator/(Number lhs, FixedPoint<I, F> rhs) {
+template <size_t I, size_t F, IsArithmetic Number>
+constexpr FixedPoint<I, F> operator/(Number lhs, FixedPoint<I, F> rhs) {
    FixedPoint<I, F> tmp(lhs);
    tmp /= rhs;
    return tmp;
 }

 // shift operators
-template <size_t I, size_t F, class Integer,
-          class = typename std::enable_if<std::is_integral<Integer>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator<<(FixedPoint<I, F> lhs, Integer rhs) {
+template <size_t I, size_t F, IsIntegral Integer>
+constexpr FixedPoint<I, F> operator<<(FixedPoint<I, F> lhs, Integer rhs) {
    lhs <<= rhs;
    return lhs;
 }
-template <size_t I, size_t F, class Integer,
-          class = typename std::enable_if<std::is_integral<Integer>::value>::type>
-CONSTEXPR14 FixedPoint<I, F> operator>>(FixedPoint<I, F> lhs, Integer rhs) {
+template <size_t I, size_t F, IsIntegral Integer>
+constexpr FixedPoint<I, F> operator>>(FixedPoint<I, F> lhs, Integer rhs) {
    lhs >>= rhs;
    return lhs;
 }

 // comparison operators
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator>(FixedPoint<I, F> lhs, Number rhs) {
    return lhs > FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator<(FixedPoint<I, F> lhs, Number rhs) {
    return lhs < FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator>=(FixedPoint<I, F> lhs, Number rhs) {
    return lhs >= FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator<=(FixedPoint<I, F> lhs, Number rhs) {
    return lhs <= FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator==(FixedPoint<I, F> lhs, Number rhs) {
    return lhs == FixedPoint<I, F>(rhs);
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator!=(FixedPoint<I, F> lhs, Number rhs) {
    return lhs != FixedPoint<I, F>(rhs);
 }

-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator>(Number lhs, FixedPoint<I, F> rhs) {
    return FixedPoint<I, F>(lhs) > rhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator<(Number lhs, FixedPoint<I, F> rhs) {
    return FixedPoint<I, F>(lhs) < rhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator>=(Number lhs, FixedPoint<I, F> rhs) {
    return FixedPoint<I, F>(lhs) >= rhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator<=(Number lhs, FixedPoint<I, F> rhs) {
    return FixedPoint<I, F>(lhs) <= rhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator==(Number lhs, FixedPoint<I, F> rhs) {
    return FixedPoint<I, F>(lhs) == rhs;
 }
-template <size_t I, size_t F, class Number,
-          class = typename std::enable_if<std::is_arithmetic<Number>::value>::type>
+template <size_t I, size_t F, IsArithmetic Number>
 constexpr bool operator!=(Number lhs, FixedPoint<I, F> rhs) {
    return FixedPoint<I, F>(lhs) != rhs;
 }

 } // namespace Common
-
-#undef CONSTEXPR14
-
-#endif
@@ -209,8 +209,8 @@ public:

    /**
     * Helper function which deduces the value type of a contiguous STL container used in ReadSpan.
-     * If T is not a contiguous STL container as defined by the concept IsSTLContainer, this calls
-     * ReadObject and T must be a trivially copyable object.
+     * If T is not a contiguous container as defined by the concept IsContiguousContainer, this
+     * calls ReadObject and T must be a trivially copyable object.
     *
     * See ReadSpan for more details if T is a contiguous container.
     * See ReadObject for more details if T is a trivially copyable object.
@@ -223,7 +223,7 @@ public:
     */
    template <typename T>
    [[nodiscard]] size_t Read(T& data) const {
-        if constexpr (IsSTLContainer<T>) {
+        if constexpr (IsContiguousContainer<T>) {
            using ContiguousType = typename T::value_type;
            static_assert(std::is_trivially_copyable_v<ContiguousType>,
                          "Data type must be trivially copyable.");
@@ -235,8 +235,8 @@ public:

    /**
     * Helper function which deduces the value type of a contiguous STL container used in WriteSpan.
-     * If T is not a contiguous STL container as defined by the concept IsSTLContainer, this calls
-     * WriteObject and T must be a trivially copyable object.
+     * If T is not a contiguous STL container as defined by the concept IsContiguousContainer, this
+     * calls WriteObject and T must be a trivially copyable object.
     *
     * See WriteSpan for more details if T is a contiguous container.
     * See WriteObject for more details if T is a trivially copyable object.
@@ -249,7 +249,7 @@ public:
     */
    template <typename T>
    [[nodiscard]] size_t Write(const T& data) const {
-        if constexpr (IsSTLContainer<T>) {
+        if constexpr (IsContiguousContainer<T>) {
            using ContiguousType = typename T::value_type;
            static_assert(std::is_trivially_copyable_v<ContiguousType>,
                          "Data type must be trivially copyable.");
@@ -18,4 +18,11 @@ struct PairHash {
    }
 };

+template <typename T>
+struct IdentityHash {
+    [[nodiscard]] size_t operator()(T value) const noexcept {
+        return static_cast<size_t>(value);
+    }
+};
+
 } // namespace Common
@@ -76,6 +76,19 @@ enum class PollingError {
    Unknown,
 };

+// Nfc reply from the controller
+enum class NfcState {
+    Success,
+    NewAmiibo,
+    WaitingForAmiibo,
+    AmiiboRemoved,
+    NotAnAmiibo,
+    NotSupported,
+    WrongDeviceState,
+    WriteFailed,
+    Unknown,
+};
+
 // Ir camera reply from the controller
 enum class CameraError {
    None,
@@ -87,7 +100,6 @@ enum class CameraError {
 enum class VibrationAmplificationType {
    Linear,
    Exponential,
-    Test,
 };

 // Analog properties for calibration
@@ -202,6 +214,11 @@ struct CameraStatus {
    std::vector<u8> data{};
 };

+struct NfcStatus {
+    NfcState state{};
+    std::vector<u8> data{};
+};
+
 // List of buttons to be passed to Qt that can be translated
 enum class ButtonNames {
    Undefined,
@@ -259,7 +276,9 @@ struct CallbackStatus {
    BodyColorStatus color_status{};
    BatteryStatus battery_status{};
    VibrationStatus vibration_status{};
-    CameraStatus camera_status{};
+    CameraFormat camera_status{CameraFormat::None};
+    NfcState nfc_status{NfcState::Unknown};
+    std::vector<u8> raw_data{};
 };

 // Triggered once every input change
@@ -305,6 +324,10 @@ public:
        return VibrationError::NotSupported;
    }

+    virtual bool IsVibrationEnabled() {
+        return false;
+    }
+
    virtual PollingError SetPollingMode([[maybe_unused]] PollingMode polling_mode) {
        return PollingError::NotSupported;
    }
@@ -312,6 +335,14 @@ public:
    virtual CameraError SetCameraFormat([[maybe_unused]] CameraFormat camera_format) {
        return CameraError::NotSupported;
    }
+
+    virtual NfcState SupportsNfc() const {
+        return NfcState::NotSupported;
+    }
+
+    virtual NfcState WriteNfcData([[maybe_unused]] const std::vector<u8>& data) {
+        return NfcState::NotSupported;
+    }
 };

 /// An abstract class template for a factory that can create input devices.
@@ -219,7 +219,7 @@ private:

    void StartBackendThread() {
        backend_thread = std::jthread([this](std::stop_token stop_token) {
-            Common::SetCurrentThreadName("yuzu:Log");
+            Common::SetCurrentThreadName("Logger");
            Entry entry;
            const auto write_logs = [this, &entry]() {
                ForEachBackend([&entry](Backend& backend) { backend.Write(entry); });
@@ -0,0 +1,9 @@
+// SPDX-FileCopyrightText: 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/multi_level_page_table.inc"
+
+namespace Common {
+template class Common::MultiLevelPageTable<u64>;
+template class Common::MultiLevelPageTable<u32>;
+} // namespace Common
@@ -0,0 +1,78 @@
+// SPDX-FileCopyrightText: 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "common/common_types.h"
+
+namespace Common {
+
+template <typename BaseAddr>
+class MultiLevelPageTable final {
+public:
+    constexpr MultiLevelPageTable() = default;
+    explicit MultiLevelPageTable(std::size_t address_space_bits, std::size_t first_level_bits,
+                                 std::size_t page_bits);
+
+    ~MultiLevelPageTable() noexcept;
+
+    MultiLevelPageTable(const MultiLevelPageTable&) = delete;
+    MultiLevelPageTable& operator=(const MultiLevelPageTable&) = delete;
+
+    MultiLevelPageTable(MultiLevelPageTable&& other) noexcept
+        : address_space_bits{std::exchange(other.address_space_bits, 0)},
+          first_level_bits{std::exchange(other.first_level_bits, 0)}, page_bits{std::exchange(
+                                                                          other.page_bits, 0)},
+          first_level_shift{std::exchange(other.first_level_shift, 0)},
+          first_level_chunk_size{std::exchange(other.first_level_chunk_size, 0)},
+          first_level_map{std::move(other.first_level_map)}, base_ptr{std::exchange(other.base_ptr,
+                                                                                    nullptr)} {}
+
+    MultiLevelPageTable& operator=(MultiLevelPageTable&& other) noexcept {
+        address_space_bits = std::exchange(other.address_space_bits, 0);
+        first_level_bits = std::exchange(other.first_level_bits, 0);
+        page_bits = std::exchange(other.page_bits, 0);
+        first_level_shift = std::exchange(other.first_level_shift, 0);
+        first_level_chunk_size = std::exchange(other.first_level_chunk_size, 0);
+        alloc_size = std::exchange(other.alloc_size, 0);
+        first_level_map = std::move(other.first_level_map);
+        base_ptr = std::exchange(other.base_ptr, nullptr);
+        return *this;
+    }
+
+    void ReserveRange(u64 start, std::size_t size);
+
+    [[nodiscard]] const BaseAddr& operator[](std::size_t index) const {
+        return base_ptr[index];
+    }
+
+    [[nodiscard]] BaseAddr& operator[](std::size_t index) {
+        return base_ptr[index];
+    }
+
+    [[nodiscard]] BaseAddr* data() {
+        return base_ptr;
+    }
+
+    [[nodiscard]] const BaseAddr* data() const {
+        return base_ptr;
+    }
+
+private:
+    void AllocateLevel(u64 level);
+
+    std::size_t address_space_bits{};
+    std::size_t first_level_bits{};
+    std::size_t page_bits{};
+    std::size_t first_level_shift{};
+    std::size_t first_level_chunk_size{};
+    std::size_t alloc_size{};
+    std::vector<void*> first_level_map{};
+    BaseAddr* base_ptr{};
+};
+
+} // namespace Common
@@ -0,0 +1,84 @@
+// SPDX-FileCopyrightText: 2021 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <sys/mman.h>
+#endif
+
+#include "common/assert.h"
+#include "common/multi_level_page_table.h"
+
+namespace Common {
+
+template <typename BaseAddr>
+MultiLevelPageTable<BaseAddr>::MultiLevelPageTable(std::size_t address_space_bits_,
+                                                   std::size_t first_level_bits_,
+                                                   std::size_t page_bits_)
+    : address_space_bits{address_space_bits_},
+      first_level_bits{first_level_bits_}, page_bits{page_bits_} {
+    if (page_bits == 0) {
+      return;
+    }
+    first_level_shift = address_space_bits - first_level_bits;
+    first_level_chunk_size = (1ULL << (first_level_shift - page_bits)) * sizeof(BaseAddr);
+    alloc_size = (1ULL << (address_space_bits - page_bits)) * sizeof(BaseAddr);
+    std::size_t first_level_size = 1ULL << first_level_bits;
+    first_level_map.resize(first_level_size, nullptr);
+#ifdef _WIN32
+    void* base{VirtualAlloc(nullptr, alloc_size, MEM_RESERVE, PAGE_READWRITE)};
+#else
+    void* base{mmap(nullptr, alloc_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0)};
+
+    if (base == MAP_FAILED) {
+        base = nullptr;
+    }
+#endif
+
+    ASSERT(base);
+    base_ptr = reinterpret_cast<BaseAddr*>(base);
+}
+
+template <typename BaseAddr>
+MultiLevelPageTable<BaseAddr>::~MultiLevelPageTable() noexcept {
+    if (!base_ptr) {
+        return;
+    }
+#ifdef _WIN32
+    ASSERT(VirtualFree(base_ptr, 0, MEM_RELEASE));
+#else
+    ASSERT(munmap(base_ptr, alloc_size) == 0);
+#endif
+}
+
+template <typename BaseAddr>
+void MultiLevelPageTable<BaseAddr>::ReserveRange(u64 start, std::size_t size) {
+    const u64 new_start = start >> first_level_shift;
+    const u64 new_end = (start + size) >> first_level_shift;
+    for (u64 i = new_start; i <= new_end; i++) {
+        if (!first_level_map[i]) {
+            AllocateLevel(i);
+        }
+    }
+}
+
+template <typename BaseAddr>
+void MultiLevelPageTable<BaseAddr>::AllocateLevel(u64 level) {
+    void* ptr = reinterpret_cast<char *>(base_ptr) + level * first_level_chunk_size;
+#ifdef _WIN32
+    void* base{VirtualAlloc(ptr, first_level_chunk_size, MEM_COMMIT, PAGE_READWRITE)};
+#else
+    void* base{mmap(ptr, first_level_chunk_size, PROT_READ | PROT_WRITE,
+                    MAP_ANONYMOUS | MAP_PRIVATE, -1, 0)};
+
+    if (base == MAP_FAILED) {
+        base = nullptr;
+    }
+#endif
+    ASSERT(base);
+
+    first_level_map[level] = base;
+}
+
+} // namespace Common
@@ -431,7 +431,7 @@ struct Values {
        FullscreenMode::Exclusive,
 #endif
        FullscreenMode::Borderless, FullscreenMode::Exclusive, "fullscreen_mode"};
-    SwitchableSetting<int, true> aspect_ratio{0, 0, 3, "aspect_ratio"};
+    SwitchableSetting<int, true> aspect_ratio{0, 0, 4, "aspect_ratio"};
    SwitchableSetting<int, true> max_anisotropy{0, 0, 5, "max_anisotropy"};
    SwitchableSetting<bool> use_speed_limit{true, "use_speed_limit"};
    SwitchableSetting<u16, true> speed_limit{100, 0, 9999, "speed_limit"};
@@ -138,8 +138,6 @@ add_library(core STATIC
    frontend/emu_window.h
    frontend/framebuffer_layout.cpp
    frontend/framebuffer_layout.h
-    hardware_interrupt_manager.cpp
-    hardware_interrupt_manager.h
    hid/emulated_console.cpp
    hid/emulated_console.h
    hid/emulated_controller.cpp
@@ -192,6 +190,9 @@ add_library(core STATIC
    hle/kernel/k_code_memory.h
    hle/kernel/k_condition_variable.cpp
    hle/kernel/k_condition_variable.h
+    hle/kernel/k_dynamic_page_manager.h
+    hle/kernel/k_dynamic_resource_manager.h
+    hle/kernel/k_dynamic_slab_heap.h
    hle/kernel/k_event.cpp
    hle/kernel/k_event.h
    hle/kernel/k_handle_table.cpp
@@ -242,6 +243,8 @@ add_library(core STATIC
    hle/kernel/k_server_session.h
    hle/kernel/k_session.cpp
    hle/kernel/k_session.h
+    hle/kernel/k_session_request.cpp
+    hle/kernel/k_session_request.h
    hle/kernel/k_shared_memory.cpp
    hle/kernel/k_shared_memory.h
    hle/kernel/k_shared_memory_info.h
@@ -263,8 +266,6 @@ add_library(core STATIC
    hle/kernel/k_worker_task.h
    hle/kernel/k_worker_task_manager.cpp
    hle/kernel/k_worker_task_manager.h
-    hle/kernel/k_writable_event.cpp
-    hle/kernel/k_writable_event.h
    hle/kernel/kernel.cpp
    hle/kernel/kernel.h
    hle/kernel/memory_types.h
@@ -460,6 +461,8 @@ add_library(core STATIC
    hle/service/hid/controllers/mouse.h
    hle/service/hid/controllers/npad.cpp
    hle/service/hid/controllers/npad.h
+    hle/service/hid/controllers/palma.cpp
+    hle/service/hid/controllers/palma.h
    hle/service/hid/controllers/stubbed.cpp
    hle/service/hid/controllers/stubbed.h
    hle/service/hid/controllers/touchscreen.cpp
@@ -494,6 +497,8 @@ add_library(core STATIC
    hle/service/jit/jit.h
    hle/service/lbl/lbl.cpp
    hle/service/lbl/lbl.h
+    hle/service/ldn/lan_discovery.cpp
+    hle/service/ldn/lan_discovery.h
    hle/service/ldn/ldn_results.h
    hle/service/ldn/ldn.cpp
    hle/service/ldn/ldn.h
@@ -521,9 +526,12 @@ add_library(core STATIC
    hle/service/nfc/nfc.h
    hle/service/nfp/amiibo_crypto.cpp
    hle/service/nfp/amiibo_crypto.h
-    hle/service/nfp/amiibo_types.h
    hle/service/nfp/nfp.cpp
    hle/service/nfp/nfp.h
+    hle/service/nfp/nfp_device.cpp
+    hle/service/nfp/nfp_device.h
+    hle/service/nfp/nfp_result.h
+    hle/service/nfp/nfp_types.h
    hle/service/nfp/nfp_user.cpp
    hle/service/nfp/nfp_user.h
    hle/service/ngct/ngct.cpp
@@ -543,6 +551,12 @@ add_library(core STATIC
    hle/service/ns/ns.h
    hle/service/ns/pdm_qry.cpp
    hle/service/ns/pdm_qry.h
+    hle/service/nvdrv/core/container.cpp
+    hle/service/nvdrv/core/container.h
+    hle/service/nvdrv/core/nvmap.cpp
+    hle/service/nvdrv/core/nvmap.h
+    hle/service/nvdrv/core/syncpoint_manager.cpp
+    hle/service/nvdrv/core/syncpoint_manager.h
    hle/service/nvdrv/devices/nvdevice.h
    hle/service/nvdrv/devices/nvdisp_disp0.cpp
    hle/service/nvdrv/devices/nvdisp_disp0.h
@@ -571,8 +585,6 @@ add_library(core STATIC
    hle/service/nvdrv/nvdrv_interface.h
    hle/service/nvdrv/nvmemp.cpp
    hle/service/nvdrv/nvmemp.h
-    hle/service/nvdrv/syncpoint_manager.cpp
-    hle/service/nvdrv/syncpoint_manager.h
    hle/service/nvflinger/binder.h
    hle/service/nvflinger/buffer_item.h
    hle/service/nvflinger/buffer_item_consumer.cpp
@@ -762,19 +774,15 @@ if (MSVC)
        /we4244 # 'conversion': conversion from 'type1' to 'type2', possible loss of data
        /we4245 # 'conversion': conversion from 'type1' to 'type2', signed/unsigned mismatch
        /we4254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
+        /we4800 # Implicit conversion from 'type' to bool. Possible information loss
    )
 else()
    target_compile_options(core PRIVATE
        -Werror=conversion
-        -Werror=ignored-qualifiers
-
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=class-memaccess>
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>
-
-        $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>

        -Wno-sign-conversion
+
+        $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>
    )
 endif()

@@ -134,6 +134,14 @@ void ARM_Interface::Run() {
        }
        system.ExitDynarmicProfile();

+        // If the thread is scheduled for termination, exit the thread.
+        if (current_thread->HasDpc()) {
+            if (current_thread->IsTerminationRequested()) {
+                current_thread->Exit();
+                UNREACHABLE();
+            }
+        }
+
        // Notify the debugger and go to sleep if a breakpoint was hit,
        // or if the thread is unable to continue for any reason.
        if (Has(hr, breakpoint) || Has(hr, no_execute)) {
@@ -450,7 +450,7 @@ std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_32::GetBacktrace(Core::S
    // Frame records are two words long:
    // fp+0 : pointer to previous frame record
    // fp+4 : value of lr for frame
-    while (true) {
+    for (size_t i = 0; i < 256; i++) {
        out.push_back({"", 0, lr, 0, ""});
        if (!fp || (fp % 4 != 0) || !memory.IsValidVirtualAddressRange(fp, 8)) {
            break;
@@ -111,6 +111,7 @@ public:
        LOG_ERROR(Core_ARM,
                  "Unimplemented instruction @ 0x{:X} for {} instructions (instr = {:08X})", pc,
                  num_instructions, memory.Read32(pc));
+        ReturnException(pc, ARM_Interface::no_execute);
    }

    void InstructionCacheOperationRaised(Dynarmic::A64::InstructionCacheOperation op,
@@ -516,7 +517,7 @@ std::vector<ARM_Interface::BacktraceEntry> ARM_Dynarmic_64::GetBacktrace(Core::S
    // Frame records are two words long:
    // fp+0 : pointer to previous frame record
    // fp+8 : value of lr for frame
-    while (true) {
+    for (size_t i = 0; i < 256; i++) {
        out.push_back({"", 0, lr, 0, ""});
        if (!fp || (fp % 4 != 0) || !memory.IsValidVirtualAddressRange(fp, 16)) {
            break;
@@ -27,7 +27,6 @@
 #include "core/file_sys/savedata_factory.h"
 #include "core/file_sys/vfs_concat.h"
 #include "core/file_sys/vfs_real.h"
-#include "core/hardware_interrupt_manager.h"
 #include "core/hid/hid_core.h"
 #include "core/hle/kernel/k_memory_manager.h"
 #include "core/hle/kernel/k_process.h"
@@ -51,6 +50,7 @@
 #include "core/telemetry_session.h"
 #include "core/tools/freezer.h"
 #include "network/network.h"
+#include "video_core/host1x/host1x.h"
 #include "video_core/renderer_base.h"
 #include "video_core/video_core.h"

@@ -133,6 +133,56 @@ struct System::Impl {
        : kernel{system}, fs_controller{system}, memory{system}, hid_core{}, room_network{},
          cpu_manager{system}, reporter{system}, applet_manager{system}, time_manager{system} {}

+    void Initialize(System& system) {
+        device_memory = std::make_unique<Core::DeviceMemory>();
+
+        is_multicore = Settings::values.use_multi_core.GetValue();
+        extended_memory_layout = Settings::values.use_extended_memory_layout.GetValue();
+
+        core_timing.SetMulticore(is_multicore);
+        core_timing.Initialize([&system]() { system.RegisterHostThread(); });
+
+        const auto posix_time = std::chrono::system_clock::now().time_since_epoch();
+        const auto current_time =
+            std::chrono::duration_cast<std::chrono::seconds>(posix_time).count();
+        Settings::values.custom_rtc_differential =
+            Settings::values.custom_rtc.value_or(current_time) - current_time;
+
+        // Create a default fs if one doesn't already exist.
+        if (virtual_filesystem == nullptr) {
+            virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
+        }
+        if (content_provider == nullptr) {
+            content_provider = std::make_unique<FileSys::ContentProviderUnion>();
+        }
+
+        // Create default implementations of applets if one is not provided.
+        applet_manager.SetDefaultAppletsIfMissing();
+
+        is_async_gpu = Settings::values.use_asynchronous_gpu_emulation.GetValue();
+
+        kernel.SetMulticore(is_multicore);
+        cpu_manager.SetMulticore(is_multicore);
+        cpu_manager.SetAsyncGpu(is_async_gpu);
+    }
+
+    void ReinitializeIfNecessary(System& system) {
+        const bool must_reinitialize =
+            is_multicore != Settings::values.use_multi_core.GetValue() ||
+            extended_memory_layout != Settings::values.use_extended_memory_layout.GetValue();
+
+        if (!must_reinitialize) {
+            return;
+        }
+
+        LOG_DEBUG(Kernel, "Re-initializing");
+
+        is_multicore = Settings::values.use_multi_core.GetValue();
+        extended_memory_layout = Settings::values.use_extended_memory_layout.GetValue();
+
+        Initialize(system);
+    }
+
    SystemResultStatus Run() {
        std::unique_lock<std::mutex> lk(suspend_guard);
        status = SystemResultStatus::Success;
@@ -178,43 +228,21 @@ struct System::Impl {
        debugger = std::make_unique<Debugger>(system, port);
    }

-    SystemResultStatus Init(System& system, Frontend::EmuWindow& emu_window) {
+    SystemResultStatus SetupForMainProcess(System& system, Frontend::EmuWindow& emu_window) {
        LOG_DEBUG(Core, "initialized OK");

-        device_memory = std::make_unique<Core::DeviceMemory>();
-
-        is_multicore = Settings::values.use_multi_core.GetValue();
-        is_async_gpu = Settings::values.use_asynchronous_gpu_emulation.GetValue();
-
-        kernel.SetMulticore(is_multicore);
-        cpu_manager.SetMulticore(is_multicore);
-        cpu_manager.SetAsyncGpu(is_async_gpu);
-        core_timing.SetMulticore(is_multicore);
+        // Setting changes may require a full system reinitialization (e.g., disabling multicore).
+        ReinitializeIfNecessary(system);

        kernel.Initialize();
        cpu_manager.Initialize();
-        core_timing.Initialize([&system]() { system.RegisterHostThread(); });
-
-        const auto posix_time = std::chrono::system_clock::now().time_since_epoch();
-        const auto current_time =
-            std::chrono::duration_cast<std::chrono::seconds>(posix_time).count();
-        Settings::values.custom_rtc_differential =
-            Settings::values.custom_rtc.value_or(current_time) - current_time;
-
-        // Create a default fs if one doesn't already exist.
-        if (virtual_filesystem == nullptr)
-            virtual_filesystem = std::make_shared<FileSys::RealVfsFilesystem>();
-        if (content_provider == nullptr)
-            content_provider = std::make_unique<FileSys::ContentProviderUnion>();
-
-        /// Create default implementations of applets if one is not provided.
-        applet_manager.SetDefaultAppletsIfMissing();

        /// Reset all glue registrations
        arp_manager.ResetAll();

        telemetry_session = std::make_unique<Core::TelemetrySession>();

+        host1x_core = std::make_unique<Tegra::Host1x::Host1x>(system);
        gpu_core = VideoCore::CreateGPU(emu_window, system);
        if (!gpu_core) {
            return SystemResultStatus::ErrorVideoCore;
@@ -224,7 +252,6 @@ struct System::Impl {

        service_manager = std::make_shared<Service::SM::ServiceManager>(kernel);
        services = std::make_unique<Service::Services>(service_manager, system);
-        interrupt_manager = std::make_unique<Hardware::InterruptManager>(system);

        // Initialize time manager, which must happen after kernel is created
        time_manager.Initialize();
@@ -253,11 +280,11 @@ struct System::Impl {
            return SystemResultStatus::ErrorGetLoader;
        }

-        SystemResultStatus init_result{Init(system, emu_window)};
+        SystemResultStatus init_result{SetupForMainProcess(system, emu_window)};
        if (init_result != SystemResultStatus::Success) {
            LOG_CRITICAL(Core, "Failed to initialize system (Error {})!",
                         static_cast<int>(init_result));
-            Shutdown();
+            ShutdownMainProcess();
            return init_result;
        }

@@ -276,7 +303,7 @@ struct System::Impl {
        const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
        if (load_result != Loader::ResultStatus::Success) {
            LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", load_result);
-            Shutdown();
+            ShutdownMainProcess();

            return static_cast<SystemResultStatus>(
                static_cast<u32>(SystemResultStatus::ErrorLoader) + static_cast<u32>(load_result));
@@ -335,7 +362,7 @@ struct System::Impl {
        return status;
    }

-    void Shutdown() {
+    void ShutdownMainProcess() {
        SetShuttingDown(true);

        // Log last frame performance stats if game was loded
@@ -363,20 +390,21 @@ struct System::Impl {
        kernel.ShutdownCores();
        cpu_manager.Shutdown();
        debugger.reset();
+        services->KillNVNFlinger();
        kernel.CloseServices();
        services.reset();
        service_manager.reset();
        cheat_engine.reset();
        telemetry_session.reset();
        time_manager.Shutdown();
-        core_timing.Shutdown();
+        core_timing.ClearPendingEvents();
        app_loader.reset();
        audio_core.reset();
        gpu_core.reset();
+        host1x_core.reset();
        perf_stats.reset();
        kernel.Shutdown();
        memory.Reset();
-        applet_manager.ClearAll();

        if (auto room_member = room_network.GetRoomMember().lock()) {
            Network::GameInfo game_info{};
@@ -450,7 +478,7 @@ struct System::Impl {
    /// AppLoader used to load the current executing application
    std::unique_ptr<Loader::AppLoader> app_loader;
    std::unique_ptr<Tegra::GPU> gpu_core;
-    std::unique_ptr<Hardware::InterruptManager> interrupt_manager;
+    std::unique_ptr<Tegra::Host1x::Host1x> host1x_core;
    std::unique_ptr<Core::DeviceMemory> device_memory;
    std::unique_ptr<AudioCore::AudioCore> audio_core;
    Core::Memory::Memory memory;
@@ -499,6 +527,7 @@ struct System::Impl {

    bool is_multicore{};
    bool is_async_gpu{};
+    bool extended_memory_layout{};

    ExecuteProgramCallback execute_program_callback;
    ExitCallback exit_callback;
@@ -519,6 +548,10 @@ const CpuManager& System::GetCpuManager() const {
    return impl->cpu_manager;
 }

+void System::Initialize() {
+    impl->Initialize(*this);
+}
+
 SystemResultStatus System::Run() {
    return impl->Run();
 }
@@ -539,8 +572,8 @@ void System::InvalidateCpuInstructionCacheRange(VAddr addr, std::size_t size) {
    impl->kernel.InvalidateCpuInstructionCacheRange(addr, size);
 }

-void System::Shutdown() {
-    impl->Shutdown();
+void System::ShutdownMainProcess() {
+    impl->ShutdownMainProcess();
 }

 bool System::IsShuttingDown() const {
@@ -668,12 +701,12 @@ const Tegra::GPU& System::GPU() const {
    return *impl->gpu_core;
 }

-Core::Hardware::InterruptManager& System::InterruptManager() {
-    return *impl->interrupt_manager;
+Tegra::Host1x::Host1x& System::Host1x() {
+    return *impl->host1x_core;
 }

-const Core::Hardware::InterruptManager& System::InterruptManager() const {
-    return *impl->interrupt_manager;
+const Tegra::Host1x::Host1x& System::Host1x() const {
+    return *impl->host1x_core;
 }

 VideoCore::RendererBase& System::Renderer() {
--- a/Show More
+++ b/Show More