nsight_aftermath_tracker: update for latest Aftermath SDK

Merge pull request #9642 from Tachi107/appstream-metadata-fix
fix(dist): wrap screenshots in <image> tags
2023-01-21 13:01:19 -05:00 · 2023-01-20 21:02:38 -08:00 · 2023-01-20 10:00:33 -08:00 · 2023-01-19 18:47:21 -08:00 · 2023-01-19 14:58:53 -05:00 · 2023-01-19 10:50:21 -08:00
307 changed files with 40058 additions and 18205 deletions
@@ -11,6 +11,7 @@ ccache -s
 mkdir build || true && cd build
 cmake .. \
      -DCMAKE_BUILD_TYPE=Release \
+      -DCMAKE_CXX_FLAGS="-march=x86-64-v2" \
      -DCMAKE_CXX_COMPILER=/usr/lib/ccache/clang++ \
      -DCMAKE_C_COMPILER=/usr/lib/ccache/clang \
      -DCMAKE_INSTALL_PREFIX="/usr" \
@@ -10,7 +10,7 @@ if grep -nrI '\s$' src *.yml *.txt *.md Doxyfile .gitignore .gitmodules .ci* dis
 fi

 # Default clang-format points to default 3.5 version one
-CLANG_FORMAT=clang-format-12
+CLANG_FORMAT=${CLANG_FORMAT:-clang-format-12}
 $CLANG_FORMAT --version

 if [ "$TRAVIS_EVENT_TYPE" = "pull_request" ]; then
@@ -12,6 +12,7 @@ mkdir build || true && cd build
 cmake .. \
      -DBoost_USE_STATIC_LIBS=ON \
      -DCMAKE_BUILD_TYPE=Release \
+      -DCMAKE_CXX_FLAGS="-march=x86-64-v2" \
      -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ \
      -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc \
      -DCMAKE_INSTALL_PREFIX="/usr" \
@@ -9,7 +9,7 @@ parameters:
 steps:
 - script: choco install vulkan-sdk
  displayName: 'Install vulkan-sdk'
- script: refreshenv && mkdir build && cd build && cmake -G "Visual Studio 17 2022" -A x64 -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DYUZU_TESTS=OFF -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DDISPLAY_VERSION=${{ parameters['version'] }} -DCMAKE_BUILD_TYPE=Release -DYUZU_CRASH_DUMPS=ON .. && cd ..
+- script: refreshenv && mkdir build && cd build && cmake -E env CXXFLAGS="/Gw /GA /Gr /Ob2" cmake -G "Visual Studio 17 2022" -A x64 -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON -DCMAKE_POLICY_DEFAULT_CMP0069=NEW -DYUZU_USE_BUNDLED_QT=1 -DYUZU_USE_BUNDLED_SDL2=1 -DYUZU_USE_QT_WEB_ENGINE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${COMPAT} -DYUZU_TESTS=OFF -DUSE_DISCORD_PRESENCE=ON -DENABLE_QT_TRANSLATION=ON -DDISPLAY_VERSION=${{ parameters['version'] }} -DCMAKE_BUILD_TYPE=Release -DYUZU_CRASH_DUMPS=ON .. && cd ..
  displayName: 'Configure CMake'
 - task: MSBuild@1
  displayName: 'Build'
@@ -3,13 +3,8 @@

 cmake_minimum_required(VERSION 3.22)

-# Dynarmic has cmake_minimum_required(3.12) and we may want to override
-# some of its variables, which is only possible in 3.13+
-set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)
-
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/CMakeModules")
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/cmake-modules")
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/externals/find-modules")
 include(DownloadExternals)
 include(CMakeDependentOption)

@@ -22,6 +17,10 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_SDL2 "Download bundled SDL2 binaries" ON
 # On Linux system SDL2 is likely to be lacking HIDAPI support which have drawbacks but is needed for SDL motion
 CMAKE_DEPENDENT_OPTION(YUZU_USE_EXTERNAL_SDL2 "Compile external SDL2" ON "ENABLE_SDL2;NOT MSVC" OFF)

+option(ENABLE_LIBUSB "Enable the use of LibUSB" ON)
+
+option(ENABLE_OPENGL "Enable OpenGL" ON)
+mark_as_advanced(FORCE ENABLE_OPENGL)
 option(ENABLE_QT "Enable the Qt frontend" ON)
 option(ENABLE_QT6 "Allow usage of Qt6 to be attempted" OFF)
 set(QT6_LOCATION "" CACHE PATH "Additional Location to search for Qt6 libraries like C:/Qt/6.3.1/msvc2019_64/")
@@ -33,6 +32,8 @@ option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)

 option(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" "${WIN32}")

+option(YUZU_USE_EXTERNAL_VULKAN_HEADERS "Use Vulkan-Headers from externals" ON)
+
 option(YUZU_USE_QT_MULTIMEDIA "Use QtMultimedia for Camera" OFF)

 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)
@@ -45,12 +46,16 @@ option(YUZU_TESTS "Compile tests" ON)

 option(YUZU_USE_PRECOMPILED_HEADERS "Use precompiled headers" ON)

+option(YUZU_ROOM "Compile LDN room server" ON)
+
 CMAKE_DEPENDENT_OPTION(YUZU_CRASH_DUMPS "Compile Windows crash dump (Minidump) support" OFF "WIN32" OFF)

 option(YUZU_USE_BUNDLED_VCPKG "Use vcpkg for yuzu dependencies" "${MSVC}")

 option(YUZU_CHECK_SUBMODULES "Check if submodules are present" ON)

+CMAKE_DEPENDENT_OPTION(YUZU_USE_FASTER_LD "Check if a faster linker is available" ON "NOT WIN32" OFF)
+
 if (YUZU_USE_BUNDLED_VCPKG)
    if (YUZU_TESTS)
        list(APPEND VCPKG_MANIFEST_FEATURES "yuzu-tests")
@@ -197,36 +202,43 @@ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/bin)
 # System imported libraries
 # =======================================================================

-find_package(enet 1.3)
+# Enforce the search mode of non-required packages for better and shorter failure messages
+find_package(enet 1.3 MODULE)
 find_package(fmt 9 REQUIRED)
-find_package(inih)
-find_package(libusb 1.0.24)
+find_package(inih MODULE)
 find_package(lz4 REQUIRED)
 find_package(nlohmann_json 3.8 REQUIRED)
-find_package(Opus 1.3)
-find_package(Vulkan 1.3.213)
+find_package(Opus 1.3 MODULE)
 find_package(ZLIB 1.2 REQUIRED)
 find_package(zstd 1.5 REQUIRED)

+if (NOT YUZU_USE_EXTERNAL_VULKAN_HEADERS)
+    find_package(Vulkan 1.3.238 REQUIRED)
+endif()
+
+if (ENABLE_LIBUSB)
+    find_package(libusb 1.0.24 MODULE)
+endif()
+
 if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
-    find_package(xbyak 6)
+    find_package(xbyak 6 CONFIG)
 endif()

 if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
-    find_package(dynarmic 6.4.0)
+    find_package(dynarmic 6.4.0 CONFIG)
 endif()

 if (ENABLE_CUBEB)
-    find_package(cubeb)
+    find_package(cubeb CONFIG)
 endif()

 if (USE_DISCORD_PRESENCE)
-    find_package(DiscordRPC)
+    find_package(DiscordRPC MODULE)
 endif()

 if (ENABLE_WEB_SERVICE)
-    find_package(cpp-jwt 1.4)
-    find_package(httplib 0.11)
+    find_package(cpp-jwt 1.4 CONFIG)
+    find_package(httplib 0.11 MODULE)
 endif()

 if (YUZU_TESTS)
@@ -579,6 +591,21 @@ if (MSVC AND CMAKE_GENERATOR STREQUAL "Ninja")
    )
 endif()

+if (YUZU_USE_FASTER_LD AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    # We will assume that if the compiler is GCC, it will attempt to use ld.bfd by default.
+    # Try to pick a faster linker.
+    find_program(LLD lld)
+    find_program(MOLD mold)
+
+    if (MOLD AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12.1")
+        message(NOTICE "Selecting mold as linker")
+        add_link_options("-fuse-ld=mold")
+    elseif (LLD)
+        message(NOTICE "Selecting lld as linker")
+        add_link_options("-fuse-ld=lld")
+    endif()
+endif()
+
 enable_testing()
 add_subdirectory(externals)
 add_subdirectory(src)
@@ -2,9 +2,7 @@
 # SPDX-License-Identifier: GPL-2.0-or-later

 find_package(PkgConfig QUIET)
-if (PKG_CONFIG_FOUND)
-    pkg_search_module(OPUS QUIET IMPORTED_TARGET opus)
-endif()
+pkg_search_module(OPUS QUIET IMPORTED_TARGET opus)

 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(Opus
@@ -3,9 +3,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later

 find_package(PkgConfig QUIET)
-if (PKG_CONFIG_FOUND)
-    pkg_search_module(ENET QUIET IMPORTED_TARGET libenet)
-endif()
+pkg_search_module(ENET QUIET IMPORTED_TARGET libenet)

 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(enet
@@ -5,13 +5,11 @@
 include(FindPackageHandleStandardArgs)

 find_package(httplib QUIET CONFIG)
-if (httplib_FOUND)
+if (httplib_CONSIDERED_CONFIGS)
    find_package_handle_standard_args(httplib CONFIG_MODE)
 else()
    find_package(PkgConfig QUIET)
-    if (PKG_CONFIG_FOUND)
-        pkg_search_module(HTTPLIB QUIET IMPORTED_TARGET cpp-httplib)
-    endif()
+    pkg_search_module(HTTPLIB QUIET IMPORTED_TARGET cpp-httplib)
    find_package_handle_standard_args(httplib
        REQUIRED_VARS HTTPLIB_INCLUDEDIR
        VERSION_VAR HTTPLIB_VERSION
@@ -3,9 +3,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later

 find_package(PkgConfig QUIET)
-if (PKG_CONFIG_FOUND)
-    pkg_search_module(INIREADER QUIET IMPORTED_TARGET INIReader)
-endif()
+pkg_search_module(INIREADER QUIET IMPORTED_TARGET INIReader)

 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(inih
@@ -3,9 +3,7 @@
 # SPDX-License-Identifier: GPL-3.0-or-later

 find_package(PkgConfig QUIET)
-if (PKG_CONFIG_FOUND)
-    pkg_search_module(LIBUSB QUIET IMPORTED_TARGET libusb-1.0)
-endif()
+pkg_search_module(LIBUSB QUIET IMPORTED_TARGET libusb-1.0)

 include(FindPackageHandleStandardArgs)
 find_package_handle_standard_args(libusb
@@ -4,13 +4,11 @@
 include(FindPackageHandleStandardArgs)

 find_package(lz4 QUIET CONFIG)
-if (lz4_FOUND)
+if (lz4_CONSIDERED_CONFIGS)
    find_package_handle_standard_args(lz4 CONFIG_MODE)
 else()
    find_package(PkgConfig QUIET)
-    if (PKG_CONFIG_FOUND)
-        pkg_search_module(LZ4 QUIET IMPORTED_TARGET liblz4)
-    endif()
+    pkg_search_module(LZ4 QUIET IMPORTED_TARGET liblz4)
    find_package_handle_standard_args(lz4
        REQUIRED_VARS LZ4_LINK_LIBRARIES
        VERSION_VAR LZ4_VERSION
@@ -4,13 +4,11 @@
 include(FindPackageHandleStandardArgs)

 find_package(zstd QUIET CONFIG)
-if (zstd_FOUND)
+if (zstd_CONSIDERED_CONFIGS)
    find_package_handle_standard_args(zstd CONFIG_MODE)
 else()
    find_package(PkgConfig QUIET)
-    if (PKG_CONFIG_FOUND)
-        pkg_search_module(ZSTD QUIET IMPORTED_TARGET libzstd)
-    endif()
+    pkg_search_module(ZSTD QUIET IMPORTED_TARGET libzstd)
    find_package_handle_standard_args(zstd
        REQUIRED_VARS ZSTD_LINK_LIBRARIES
        VERSION_VAR ZSTD_VERSION
@@ -53,10 +53,10 @@ SPDX-License-Identifier: CC0-1.0
  <developer_name>yuzu Emulator Team</developer_name>
  <content_rating type="oars-1.0"/>
  <screenshots>
-    <screenshot type="default">https://raw.githubusercontent.com/yuzu-emu/yuzu-emu.github.io/master/images/screenshots/001-Super%20Mario%20Odyssey%20.png</screenshot>
-    <screenshot>https://raw.githubusercontent.com/yuzu-emu/yuzu-emu.github.io/master/images/screenshots/004-The%20Legend%20of%20Zelda%20Skyward%20Sword%20HD.png</screenshot>
-    <screenshot>https://raw.githubusercontent.com/yuzu-emu/yuzu-emu.github.io/master/images/screenshots/007-Pokemon%20Sword.png</screenshot>
-    <screenshot>https://raw.githubusercontent.com/yuzu-emu/yuzu-emu.github.io/master/images/screenshots/010-Hyrule%20Warriors%20Age%20of%20Calamity.png</screenshot>
-    <screenshot>https://raw.githubusercontent.com/yuzu-emu/yuzu-emu.github.io/master/images/screenshots/039-Pok%C3%A9mon%20Mystery%20Dungeon%20Rescue%20Team%20DX.png.png.png</screenshot>
+    <screenshot type="default"><image>https://raw.githubusercontent.com/yuzu-emu/yuzu-emu.github.io/master/images/screenshots/001-Super%20Mario%20Odyssey%20.png</image></screenshot>
+    <screenshot><image>https://raw.githubusercontent.com/yuzu-emu/yuzu-emu.github.io/master/images/screenshots/004-The%20Legend%20of%20Zelda%20Skyward%20Sword%20HD.png</image></screenshot>
+    <screenshot><image>https://raw.githubusercontent.com/yuzu-emu/yuzu-emu.github.io/master/images/screenshots/007-Pokemon%20Sword.png</image></screenshot>
+    <screenshot><image>https://raw.githubusercontent.com/yuzu-emu/yuzu-emu.github.io/master/images/screenshots/010-Hyrule%20Warriors%20Age%20of%20Calamity.png</image></screenshot>
+    <screenshot><image>https://raw.githubusercontent.com/yuzu-emu/yuzu-emu.github.io/master/images/screenshots/039-Pok%C3%A9mon%20Mystery%20Dungeon%20Rescue%20Team%20DX.png.png.png</image></screenshot>
  </screenshots>
 </component>
@@ -1,9 +1,9 @@
 # SPDX-FileCopyrightText: 2016 Citra Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later

-list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/CMakeModules")
-list(APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/externals/find-modules")
-include(DownloadExternals)
+# Dynarmic has cmake_minimum_required(3.12) and we may want to override
+# some of its variables, which is only possible in 3.13+
+set(CMAKE_POLICY_DEFAULT_CMP0077 NEW)

 # xbyak
 if ((ARCHITECTURE_x86 OR ARCHITECTURE_x86_64) AND NOT TARGET xbyak::xbyak)
@@ -12,8 +12,7 @@ endif()

 # Dynarmic
 if ((ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64) AND NOT TARGET dynarmic::dynarmic)
-    set(DYNARMIC_NO_BUNDLED_FMT ON)
-    set(DYNARMIC_IGNORE_ASSERTS ON CACHE BOOL "" FORCE)
+    set(DYNARMIC_IGNORE_ASSERTS ON)
    add_subdirectory(dynarmic EXCLUDE_FROM_ALL)
    add_library(dynarmic::dynarmic ALIAS dynarmic)
 endif()
@@ -45,7 +44,7 @@ if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "12" AND CMAKE_CXX_COMPILER
 endif()

 # libusb
-if (NOT TARGET libusb::usb)
+if (ENABLE_LIBUSB AND NOT TARGET libusb::usb)
    add_subdirectory(libusb EXCLUDE_FROM_ALL)
 endif()

@@ -60,10 +59,10 @@ if (YUZU_USE_EXTERNAL_SDL2)
            Locale Power Render)
        foreach(_SUB ${SDL_UNUSED_SUBSYSTEMS})
          string(TOUPPER ${_SUB} _OPT)
-          option(SDL_${_OPT} "" OFF)
+          set(SDL_${_OPT} OFF)
        endforeach()

-        option(HIDAPI "" ON)
+        set(HIDAPI ON)
    endif()
    set(SDL_STATIC ON)
    set(SDL_SHARED OFF)
@@ -83,7 +82,7 @@ endif()

 # Cubeb
 if (ENABLE_CUBEB AND NOT TARGET cubeb::cubeb)
-    set(BUILD_TESTS OFF CACHE BOOL "")
+    set(BUILD_TESTS OFF)
    add_subdirectory(cubeb EXCLUDE_FROM_ALL)
    add_library(cubeb::cubeb ALIAS cubeb)
 endif()
@@ -98,6 +97,7 @@ endif()
 # Sirit
 add_subdirectory(sirit EXCLUDE_FROM_ALL)

+# httplib
 if (ENABLE_WEB_SERVICE AND NOT TARGET httplib::httplib)
    if (NOT WIN32)
        find_package(OpenSSL 1.1)
@@ -108,7 +108,7 @@ if (ENABLE_WEB_SERVICE AND NOT TARGET httplib::httplib)

    if (WIN32 OR NOT OPENSSL_FOUND)
        # LibreSSL
-        set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
+        set(LIBRESSL_SKIP_INSTALL ON)
        set(OPENSSLDIR "/etc/ssl/")
        add_subdirectory(libressl EXCLUDE_FROM_ALL)
        target_include_directories(ssl INTERFACE ./libressl/include)
@@ -118,7 +118,6 @@ if (ENABLE_WEB_SERVICE AND NOT TARGET httplib::httplib)
            DEFINITION OPENSSL_LIBS)
    endif()

-    # httplib
    add_library(httplib INTERFACE)
    target_include_directories(httplib INTERFACE ./cpp-httplib)
    target_compile_definitions(httplib INTERFACE -DCPPHTTPLIB_OPENSSL_SUPPORT)
@@ -152,6 +151,6 @@ if (YUZU_USE_BUNDLED_FFMPEG)
 endif()

 # Vulkan-Headers
-if (NOT TARGET Vulkan::Headers)
+if (YUZU_USE_EXTERNAL_VULKAN_HEADERS)
    add_subdirectory(Vulkan-Headers EXCLUDE_FROM_ALL)
 endif()
@@ -161,7 +161,10 @@ add_subdirectory(video_core)
 add_subdirectory(network)
 add_subdirectory(input_common)
 add_subdirectory(shader_recompiler)
-add_subdirectory(dedicated_room)
+
+if (YUZU_ROOM)
+     add_subdirectory(dedicated_room)
+endif()

 if (YUZU_TESTS)
    add_subdirectory(tests)
@@ -187,11 +187,7 @@ add_library(audio_core STATIC
    renderer/voice/voice_info.cpp
    renderer/voice/voice_info.h
    renderer/voice/voice_state.h
-    sink/cubeb_sink.cpp
-    sink/cubeb_sink.h
    sink/null_sink.h
-    sink/sdl2_sink.cpp
-    sink/sdl2_sink.h
    sink/sink.h
    sink/sink_details.cpp
    sink/sink_details.h
@@ -222,11 +218,22 @@ if (ARCHITECTURE_x86_64 OR ARCHITECTURE_arm64)
    target_link_libraries(audio_core PRIVATE dynarmic::dynarmic)
 endif()

-if(ENABLE_CUBEB)
+if (ENABLE_CUBEB)
+    target_sources(audio_core PRIVATE
+        sink/cubeb_sink.cpp
+        sink/cubeb_sink.h
+    )
+
    target_link_libraries(audio_core PRIVATE cubeb::cubeb)
    target_compile_definitions(audio_core PRIVATE -DHAVE_CUBEB=1)
 endif()
-if(ENABLE_SDL2)
+
+if (ENABLE_SDL2)
+    target_sources(audio_core PRIVATE
+        sink/sdl2_sink.cpp
+        sink/sdl2_sink.h
+    )
+
    target_link_libraries(audio_core PRIVATE SDL2::SDL2)
    target_compile_definitions(audio_core PRIVATE HAVE_SDL2)
 endif()
@@ -91,9 +91,10 @@ public:
     * @param core_timing - The CoreTiming instance
     * @param session     - The device session
     *
-     * @return Is the buffer was released.
+     * @return If any buffer was released.
     */
-    bool ReleaseBuffers(const Core::Timing::CoreTiming& core_timing, const DeviceSession& session) {
+    bool ReleaseBuffers(const Core::Timing::CoreTiming& core_timing, const DeviceSession& session,
+                        bool force) {
        std::scoped_lock l{lock};
        bool buffer_released{false};
        while (registered_count > 0) {
@@ -103,7 +104,8 @@ public:
            }

            // Check with the backend if this buffer can be released yet.
-            if (!session.IsBufferConsumed(buffers[index])) {
+            // If we're shutting down, we don't care if it's been played or not.
+            if (!force && !session.IsBufferConsumed(buffers[index])) {
                break;
            }

@@ -73,6 +73,12 @@ void DeviceSession::Stop() {
    }
 }

+void DeviceSession::ClearBuffers() {
+    if (stream) {
+        stream->ClearQueue();
+    }
+}
+
 void DeviceSession::AppendBuffers(std::span<const AudioBuffer> buffers) const {
    for (const auto& buffer : buffers) {
        Sink::SinkBuffer new_buffer{
@@ -90,6 +90,11 @@ public:
     */
    void Stop();

+    /**
+     * Clear out the underlying audio buffers in the backend stream.
+     */
+    void ClearBuffers();
+
    /**
     * Set this device session's volume.
     *
@@ -23,7 +23,6 @@ System::~System() {
 void System::Finalize() {
    Stop();
    session->Finalize();
-    buffer_event->Signal();
 }

 void System::StartSession() {
@@ -102,6 +101,10 @@ Result System::Stop() {
    if (state == State::Started) {
        session->Stop();
        session->SetVolume(0.0f);
+        session->ClearBuffers();
+        if (buffers.ReleaseBuffers(system.CoreTiming(), *session, true)) {
+            buffer_event->Signal();
+        }
        state = State::Stopped;
    }

@@ -138,7 +141,7 @@ void System::RegisterBuffers() {
 }

 void System::ReleaseBuffers() {
-    bool signal{buffers.ReleaseBuffers(system.CoreTiming(), *session)};
+    bool signal{buffers.ReleaseBuffers(system.CoreTiming(), *session, false)};

    if (signal) {
        // Signal if any buffer was released, or if none are registered, we need more.
@@ -24,7 +24,6 @@ System::~System() {
 void System::Finalize() {
    Stop();
    session->Finalize();
-    buffer_event->Signal();
 }

 std::string_view System::GetDefaultOutputDeviceName() const {
@@ -102,6 +101,10 @@ Result System::Stop() {
    if (state == State::Started) {
        session->Stop();
        session->SetVolume(0.0f);
+        session->ClearBuffers();
+        if (buffers.ReleaseBuffers(system.CoreTiming(), *session, true)) {
+            buffer_event->Signal();
+        }
        state = State::Stopped;
    }

@@ -138,7 +141,7 @@ void System::RegisterBuffers() {
 }

 void System::ReleaseBuffers() {
-    bool signal{buffers.ReleaseBuffers(system.CoreTiming(), *session)};
+    bool signal{buffers.ReleaseBuffers(system.CoreTiming(), *session, false)};
    if (signal) {
        // Signal if any buffer was released, or if none are registered, we need more.
        buffer_event->Signal();
@@ -20,25 +20,25 @@ static void SrcProcessFrame(std::span<s32> output, std::span<const s32> input,
                            const u32 target_sample_count, const u32 source_sample_count,
                            UpsamplerState* state) {
    constexpr u32 WindowSize = 10;
-    constexpr std::array<Common::FixedPoint<24, 8>, WindowSize> SincWindow1{
-        51.93359375f, -18.80078125f, 9.73046875f, -5.33203125f, 2.84375f,
-        -1.41015625f, 0.62109375f,   -0.2265625f, 0.0625f,      -0.00390625f,
+    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc1{
+        0.95376587f,   -0.12872314f, 0.060028076f,  -0.032470703f, 0.017669678f,
+        -0.009124756f, 0.004272461f, -0.001739502f, 0.000579834f,  -0.000091552734f,
    };
-    constexpr std::array<Common::FixedPoint<24, 8>, WindowSize> SincWindow2{
-        105.35546875f, -24.52734375f, 11.9609375f,  -6.515625f, 3.52734375f,
-        -1.796875f,    0.828125f,     -0.32421875f, 0.1015625f, -0.015625f,
+    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc2{
+        0.8230896f,    -0.19161987f,  0.093444824f,  -0.05090332f,   0.027557373f,
+        -0.014038086f, 0.0064697266f, -0.002532959f, 0.00079345703f, -0.00012207031f,
    };
-    constexpr std::array<Common::FixedPoint<24, 8>, WindowSize> SincWindow3{
-        122.08203125f, -16.47656250f, 7.68359375f,  -4.15625000f, 2.26171875f,
-        -1.16796875f,  0.54687500f,   -0.22265625f, 0.07421875f,  -0.01171875f,
+    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc3{
+        0.6298828f,    -0.19274902f, 0.09725952f,    -0.05319214f,  0.028625488f,
+        -0.014373779f, 0.006500244f, -0.0024719238f, 0.0007324219f, -0.000091552734f,
    };
-    constexpr std::array<Common::FixedPoint<24, 8>, WindowSize> SincWindow4{
-        23.73437500f, -9.62109375f, 5.07812500f,  -2.78125000f, 1.46875000f,
-        -0.71484375f, 0.30859375f,  -0.10546875f, 0.02734375f,  0.00000000f,
+    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc4{
+        0.4057312f,    -0.1468811f,  0.07601929f,    -0.041656494f,  0.022216797f,
+        -0.011016846f, 0.004852295f, -0.0017700195f, 0.00048828125f, -0.000030517578f,
    };
-    constexpr std::array<Common::FixedPoint<24, 8>, WindowSize> SincWindow5{
-        80.62500000f, -24.67187500f, 12.44921875f, -6.80859375f, 3.66406250f,
-        -1.83984375f, 0.83203125f,   -0.31640625f, 0.09375000f,  -0.01171875f,
+    constexpr std::array<Common::FixedPoint<17, 15>, WindowSize> WindowedSinc5{
+        0.1854248f,    -0.075164795f, 0.03967285f,    -0.021728516f,  0.011474609f,
+        -0.005584717f, 0.0024108887f, -0.0008239746f, 0.00021362305f, 0.0f,
    };

    if (!state->initialized) {
@@ -91,52 +91,31 @@ static void SrcProcessFrame(std::span<s32> output, std::span<const s32> input,
            static_cast<u16>((state->history_output_index + 1) % UpsamplerState::HistorySize);
    };

-    auto calculate_sample = [&state](std::span<const Common::FixedPoint<24, 8>> coeffs1,
-                                     std::span<const Common::FixedPoint<24, 8>> coeffs2) -> s32 {
+    auto calculate_sample = [&state](std::span<const Common::FixedPoint<17, 15>> coeffs1,
+                                     std::span<const Common::FixedPoint<17, 15>> coeffs2) -> s32 {
        auto output_index{state->history_output_index};
-        auto start_pos{output_index - state->history_start_index + 1U};
-        auto end_pos{10U};
+        u64 result{0};

-        if (start_pos < 10) {
-            end_pos = start_pos;
-        }
+        for (u32 coeff_index = 0; coeff_index < 10; coeff_index++) {
+            result += static_cast<u64>(state->history[output_index].to_raw()) *
+                      coeffs1[coeff_index].to_raw();

-        u64 prev_contrib{0};
-        u32 coeff_index{0};
-        for (; coeff_index < end_pos; coeff_index++, output_index--) {
-            prev_contrib += static_cast<u64>(state->history[output_index].to_raw()) *
-                            coeffs1[coeff_index].to_raw();
-        }
-
-        auto end_index{state->history_end_index};
-        for (; start_pos < 9; start_pos++, coeff_index++, end_index--) {
-            prev_contrib += static_cast<u64>(state->history[end_index].to_raw()) *
-                            coeffs1[coeff_index].to_raw();
+            output_index = output_index == state->history_start_index ? state->history_end_index
+                                                                      : output_index - 1;
        }

        output_index =
            static_cast<u16>((state->history_output_index + 1) % UpsamplerState::HistorySize);
-        start_pos = state->history_end_index - output_index + 1U;
-        end_pos = 10U;

-        if (start_pos < 10) {
-            end_pos = start_pos;
+        for (u32 coeff_index = 0; coeff_index < 10; coeff_index++) {
+            result += static_cast<u64>(state->history[output_index].to_raw()) *
+                      coeffs2[coeff_index].to_raw();
+
+            output_index = output_index == state->history_end_index ? state->history_start_index
+                                                                    : output_index + 1;
        }

-        u64 next_contrib{0};
-        coeff_index = 0;
-        for (; coeff_index < end_pos; coeff_index++, output_index++) {
-            next_contrib += static_cast<u64>(state->history[output_index].to_raw()) *
-                            coeffs2[coeff_index].to_raw();
-        }
-
-        auto start_index{state->history_start_index};
-        for (; start_pos < 9; start_pos++, start_index++, coeff_index++) {
-            next_contrib += static_cast<u64>(state->history[start_index].to_raw()) *
-                            coeffs2[coeff_index].to_raw();
-        }
-
-        return static_cast<s32>(((prev_contrib >> 15) + (next_contrib >> 15)) >> 8);
+        return static_cast<s32>(result >> (8 + 15));
    };

    switch (state->ratio.to_int_floor()) {
@@ -150,23 +129,23 @@ static void SrcProcessFrame(std::span<s32> output, std::span<const s32> input,
                break;

            case 1:
-                output[write_index] = calculate_sample(SincWindow3, SincWindow4);
+                output[write_index] = calculate_sample(WindowedSinc1, WindowedSinc5);
                break;

            case 2:
-                output[write_index] = calculate_sample(SincWindow2, SincWindow1);
+                output[write_index] = calculate_sample(WindowedSinc2, WindowedSinc4);
                break;

            case 3:
-                output[write_index] = calculate_sample(SincWindow5, SincWindow5);
+                output[write_index] = calculate_sample(WindowedSinc3, WindowedSinc3);
                break;

            case 4:
-                output[write_index] = calculate_sample(SincWindow1, SincWindow2);
+                output[write_index] = calculate_sample(WindowedSinc4, WindowedSinc2);
                break;

            case 5:
-                output[write_index] = calculate_sample(SincWindow4, SincWindow3);
+                output[write_index] = calculate_sample(WindowedSinc5, WindowedSinc1);
                break;
            }
            state->sample_index = static_cast<u8>((state->sample_index + 1) % 6);
@@ -183,11 +162,11 @@ static void SrcProcessFrame(std::span<s32> output, std::span<const s32> input,
                break;

            case 1:
-                output[write_index] = calculate_sample(SincWindow2, SincWindow1);
+                output[write_index] = calculate_sample(WindowedSinc2, WindowedSinc4);
                break;

            case 2:
-                output[write_index] = calculate_sample(SincWindow1, SincWindow2);
+                output[write_index] = calculate_sample(WindowedSinc4, WindowedSinc2);
                break;
            }
            state->sample_index = static_cast<u8>((state->sample_index + 1) % 3);
@@ -204,12 +183,12 @@ static void SrcProcessFrame(std::span<s32> output, std::span<const s32> input,
                break;

            case 1:
-                output[write_index] = calculate_sample(SincWindow1, SincWindow2);
+                output[write_index] = calculate_sample(WindowedSinc4, WindowedSinc2);
                break;

            case 2:
                increment();
-                output[write_index] = calculate_sample(SincWindow2, SincWindow1);
+                output[write_index] = calculate_sample(WindowedSinc2, WindowedSinc4);
                break;
            }
            state->sample_index = static_cast<u8>((state->sample_index + 1) % 3);
@@ -16,7 +16,6 @@ class CommandGenerator;
 */
 class DetailAspect {
 public:
-    DetailAspect() = default;
    DetailAspect(CommandGenerator& command_generator, PerformanceEntryType entry_type, s32 node_id,
                 PerformanceDetailType detail_type);

@@ -16,7 +16,6 @@ class CommandGenerator;
 */
 class EntryAspect {
 public:
-    EntryAspect() = default;
    EntryAspect(CommandGenerator& command_generator, PerformanceEntryType type, s32 node_id);

    /// Command generator the command will be generated into
@@ -34,8 +34,6 @@ add_library(common STATIC
    bit_util.h
    cityhash.cpp
    cityhash.h
-    cache_management.cpp
-    cache_management.h
    common_funcs.h
    common_precompiled_headers.h
    common_types.h
@@ -80,6 +78,7 @@ add_library(common STATIC
    logging/types.h
    lz4_compression.cpp
    lz4_compression.h
+    make_unique_for_overwrite.h
    math_util.h
    memory_detect.cpp
    memory_detect.h
@@ -98,11 +97,13 @@ add_library(common STATIC
    point.h
    precompiled_headers.h
    quaternion.h
+    range_map.h
    reader_writer_queue.h
    ring_buffer.h
    ${CMAKE_CURRENT_BINARY_DIR}/scm_rev.cpp
    scm_rev.h
    scope_exit.h
+    scratch_buffer.h
    settings.cpp
    settings.h
    settings_input.cpp
@@ -69,7 +69,7 @@ void assert_fail_impl();
 #define ASSERT_OR_EXECUTE(_a_, _b_)                                                                \
    do {                                                                                           \
        ASSERT(_a_);                                                                               \
-        if (!(_a_)) {                                                                              \
+        if (!(_a_)) [[unlikely]] {                                                                 \
            _b_                                                                                    \
        }                                                                                          \
    } while (0)
@@ -78,7 +78,7 @@ void assert_fail_impl();
 #define ASSERT_OR_EXECUTE_MSG(_a_, _b_, ...)                                                       \
    do {                                                                                           \
        ASSERT_MSG(_a_, __VA_ARGS__);                                                              \
-        if (!(_a_)) {                                                                              \
+        if (!(_a_)) [[unlikely]] {                                                                 \
            _b_                                                                                    \
        }                                                                                          \
    } while (0)
@@ -1,59 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <cstdint>
-#include <cstring>
-
-#include "common/cache_management.h"
-
-namespace Common {
-
-#if defined(ARCHITECTURE_x86_64)
-
-// Most cache operations are no-ops on x86
-
-void DataCacheLineCleanByVAToPoU(void* start, size_t size) {}
-void DataCacheLineCleanAndInvalidateByVAToPoC(void* start, size_t size) {}
-void DataCacheLineCleanByVAToPoC(void* start, size_t size) {}
-void DataCacheZeroByVA(void* start, size_t size) {
-    std::memset(start, 0, size);
-}
-
-#elif defined(ARCHITECTURE_arm64)
-
-// BS/DminLine is log2(cache size in words), we want size in bytes
-#define EXTRACT_DMINLINE(ctr_el0) (1 << ((((ctr_el0) >> 16) & 0xf) + 2))
-#define EXTRACT_BS(dczid_el0) (1 << (((dczid_el0)&0xf) + 2))
-
-#define DEFINE_DC_OP(op_name, function_name)                                                       \
-    void function_name(void* start, size_t size) {                                                 \
-        size_t ctr_el0;                                                                            \
-        asm volatile("mrs %[ctr_el0], ctr_el0\n\t" : [ctr_el0] "=r"(ctr_el0));                     \
-        size_t cacheline_size = EXTRACT_DMINLINE(ctr_el0);                                         \
-        uintptr_t va_start = reinterpret_cast<uintptr_t>(start);                                   \
-        uintptr_t va_end = va_start + size;                                                        \
-        for (uintptr_t va = va_start; va < va_end; va += cacheline_size) {                         \
-            asm volatile("dc " #op_name ", %[va]\n\t" : : [va] "r"(va) : "memory");                \
-        }                                                                                          \
-    }
-
-#define DEFINE_DC_OP_DCZID(op_name, function_name)                                                 \
-    void function_name(void* start, size_t size) {                                                 \
-        size_t dczid_el0;                                                                          \
-        asm volatile("mrs %[dczid_el0], dczid_el0\n\t" : [dczid_el0] "=r"(dczid_el0));             \
-        size_t cacheline_size = EXTRACT_BS(dczid_el0);                                             \
-        uintptr_t va_start = reinterpret_cast<uintptr_t>(start);                                   \
-        uintptr_t va_end = va_start + size;                                                        \
-        for (uintptr_t va = va_start; va < va_end; va += cacheline_size) {                         \
-            asm volatile("dc " #op_name ", %[va]\n\t" : : [va] "r"(va) : "memory");                \
-        }                                                                                          \
-    }
-
-DEFINE_DC_OP(cvau, DataCacheLineCleanByVAToPoU);
-DEFINE_DC_OP(civac, DataCacheLineCleanAndInvalidateByVAToPoC);
-DEFINE_DC_OP(cvac, DataCacheLineCleanByVAToPoC);
-DEFINE_DC_OP_DCZID(zva, DataCacheZeroByVA);
-
-#endif
-
-} // namespace Common
@@ -1,27 +0,0 @@
-// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <cstddef>
-
-namespace Common {
-
-// Data cache instructions enabled at EL0 by SCTLR_EL1.UCI.
-// VA = virtual address
-// PoC = point of coherency
-// PoU = point of unification
-
-// dc cvau
-void DataCacheLineCleanByVAToPoU(void* start, size_t size);
-
-// dc civac
-void DataCacheLineCleanAndInvalidateByVAToPoC(void* start, size_t size);
-
-// dc cvac
-void DataCacheLineCleanByVAToPoC(void* start, size_t size);
-
-// dc zva
-void DataCacheZeroByVA(void* start, size_t size);
-
-} // namespace Common
@@ -393,12 +393,27 @@ public:
        }

        // Virtual memory initialization
-        virtual_base = static_cast<u8*>(
-            mmap(nullptr, virtual_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+#if defined(__FreeBSD__)
+        virtual_base =
+            static_cast<u8*>(mmap(nullptr, virtual_size, PROT_NONE,
+                                  MAP_PRIVATE | MAP_ANONYMOUS | MAP_ALIGNED_SUPER, -1, 0));
+        if (virtual_base == MAP_FAILED) {
+            virtual_base = static_cast<u8*>(
+                mmap(nullptr, virtual_size, PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0));
+            if (virtual_base == MAP_FAILED) {
+                LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
+                throw std::bad_alloc{};
+            }
+        }
+#else
+        virtual_base = static_cast<u8*>(mmap(nullptr, virtual_size, PROT_NONE,
+                                             MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0));
        if (virtual_base == MAP_FAILED) {
            LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
            throw std::bad_alloc{};
        }
+        madvise(virtual_base, virtual_size, MADV_HUGEPAGE);
+#endif

        good = true;
    }
@@ -292,9 +292,6 @@ class InputDevice {
 public:
    virtual ~InputDevice() = default;

-    // Request input device to update if necessary
-    virtual void SoftUpdate() {}
-
    // Force input device to update data regardless of the current state
    virtual void ForceUpdate() {}

@@ -0,0 +1,25 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+#include <type_traits>
+
+namespace Common {
+
+template <class T>
+requires(!std::is_array_v<T>) std::unique_ptr<T> make_unique_for_overwrite() {
+    return std::unique_ptr<T>(new T);
+}
+
+template <class T>
+requires std::is_unbounded_array_v<T> std::unique_ptr<T> make_unique_for_overwrite(std::size_t n) {
+    return std::unique_ptr<T>(new std::remove_extent_t<T>[n]);
+}
+
+template <class T, class... Args>
+requires std::is_bounded_array_v<T>
+void make_unique_for_overwrite(Args&&...) = delete;
+
+} // namespace Common
@@ -0,0 +1,139 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include <map>
+#include <type_traits>
+
+#include "common/common_types.h"
+
+namespace Common {
+
+template <typename KeyTBase, typename ValueT>
+class RangeMap {
+private:
+    using KeyT =
+        std::conditional_t<std::is_signed_v<KeyTBase>, KeyTBase, std::make_signed_t<KeyTBase>>;
+
+public:
+    explicit RangeMap(ValueT null_value_) : null_value{null_value_} {
+        container.emplace(std::numeric_limits<KeyT>::min(), null_value);
+    };
+    ~RangeMap() = default;
+
+    void Map(KeyTBase address, KeyTBase address_end, ValueT value) {
+        KeyT new_address = static_cast<KeyT>(address);
+        KeyT new_address_end = static_cast<KeyT>(address_end);
+        if (new_address < 0) {
+            new_address = 0;
+        }
+        if (new_address_end < 0) {
+            new_address_end = 0;
+        }
+        InternalMap(new_address, new_address_end, value);
+    }
+
+    void Unmap(KeyTBase address, KeyTBase address_end) {
+        Map(address, address_end, null_value);
+    }
+
+    [[nodiscard]] size_t GetContinousSizeFrom(KeyTBase address) const {
+        const KeyT new_address = static_cast<KeyT>(address);
+        if (new_address < 0) {
+            return 0;
+        }
+        return ContinousSizeInternal(new_address);
+    }
+
+    [[nodiscard]] ValueT GetValueAt(KeyT address) const {
+        const KeyT new_address = static_cast<KeyT>(address);
+        if (new_address < 0) {
+            return null_value;
+        }
+        return GetValueInternal(new_address);
+    }
+
+private:
+    using MapType = std::map<KeyT, ValueT>;
+    using IteratorType = typename MapType::iterator;
+    using ConstIteratorType = typename MapType::const_iterator;
+
+    size_t ContinousSizeInternal(KeyT address) const {
+        const auto it = GetFirstElementBeforeOrOn(address);
+        if (it == container.end() || it->second == null_value) {
+            return 0;
+        }
+        const auto it_end = std::next(it);
+        if (it_end == container.end()) {
+            return std::numeric_limits<KeyT>::max() - address;
+        }
+        return it_end->first - address;
+    }
+
+    ValueT GetValueInternal(KeyT address) const {
+        const auto it = GetFirstElementBeforeOrOn(address);
+        if (it == container.end()) {
+            return null_value;
+        }
+        return it->second;
+    }
+
+    ConstIteratorType GetFirstElementBeforeOrOn(KeyT address) const {
+        auto it = container.lower_bound(address);
+        if (it == container.begin()) {
+            return it;
+        }
+        if (it != container.end() && (it->first == address)) {
+            return it;
+        }
+        --it;
+        return it;
+    }
+
+    ValueT GetFirstValueWithin(KeyT address) {
+        auto it = container.lower_bound(address);
+        if (it == container.begin()) {
+            return it->second;
+        }
+        if (it == container.end()) [[unlikely]] { // this would be a bug
+            return null_value;
+        }
+        --it;
+        return it->second;
+    }
+
+    ValueT GetLastValueWithin(KeyT address) {
+        auto it = container.upper_bound(address);
+        if (it == container.end()) {
+            return null_value;
+        }
+        if (it == container.begin()) [[unlikely]] { // this would be a bug
+            return it->second;
+        }
+        --it;
+        return it->second;
+    }
+
+    void InternalMap(KeyT address, KeyT address_end, ValueT value) {
+        const bool must_add_start = GetFirstValueWithin(address) != value;
+        const ValueT last_value = GetLastValueWithin(address_end);
+        const bool must_add_end = last_value != value;
+        auto it = container.lower_bound(address);
+        const auto it_end = container.upper_bound(address_end);
+        while (it != it_end) {
+            it = container.erase(it);
+        }
+        if (must_add_start) {
+            container.emplace(address, value);
+        }
+        if (must_add_end) {
+            container.emplace(address_end, last_value);
+        }
+    }
+
+    ValueT null_value;
+    MapType container;
+};
+
+} // namespace Common
@@ -0,0 +1,95 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/make_unique_for_overwrite.h"
+
+namespace Common {
+
+/**
+ * ScratchBuffer class
+ * This class creates a default initialized heap allocated buffer for cases such as intermediate
+ * buffers being copied into entirely, where value initializing members during allocation or resize
+ * is redundant.
+ */
+template <typename T>
+class ScratchBuffer {
+public:
+    ScratchBuffer() = default;
+
+    explicit ScratchBuffer(size_t initial_capacity)
+        : last_requested_size{initial_capacity}, buffer_capacity{initial_capacity},
+          buffer{Common::make_unique_for_overwrite<T[]>(initial_capacity)} {}
+
+    ~ScratchBuffer() = default;
+
+    /// This will only grow the buffer's capacity if size is greater than the current capacity.
+    /// The previously held data will remain intact.
+    void resize(size_t size) {
+        if (size > buffer_capacity) {
+            auto new_buffer = Common::make_unique_for_overwrite<T[]>(size);
+            std::move(buffer.get(), buffer.get() + buffer_capacity, new_buffer.get());
+            buffer = std::move(new_buffer);
+            buffer_capacity = size;
+        }
+        last_requested_size = size;
+    }
+
+    /// This will only grow the buffer's capacity if size is greater than the current capacity.
+    /// The previously held data will be destroyed if a reallocation occurs.
+    void resize_destructive(size_t size) {
+        if (size > buffer_capacity) {
+            buffer_capacity = size;
+            buffer = Common::make_unique_for_overwrite<T[]>(buffer_capacity);
+        }
+        last_requested_size = size;
+    }
+
+    [[nodiscard]] T* data() noexcept {
+        return buffer.get();
+    }
+
+    [[nodiscard]] const T* data() const noexcept {
+        return buffer.get();
+    }
+
+    [[nodiscard]] T* begin() noexcept {
+        return data();
+    }
+
+    [[nodiscard]] const T* begin() const noexcept {
+        return data();
+    }
+
+    [[nodiscard]] T* end() noexcept {
+        return data() + last_requested_size;
+    }
+
+    [[nodiscard]] const T* end() const noexcept {
+        return data() + last_requested_size;
+    }
+
+    [[nodiscard]] T& operator[](size_t i) {
+        return buffer[i];
+    }
+
+    [[nodiscard]] const T& operator[](size_t i) const {
+        return buffer[i];
+    }
+
+    [[nodiscard]] size_t size() const noexcept {
+        return last_requested_size;
+    }
+
+    [[nodiscard]] size_t capacity() const noexcept {
+        return buffer_capacity;
+    }
+
+private:
+    size_t last_requested_size{};
+    size_t buffer_capacity{};
+    std::unique_ptr<T[]> buffer{};
+};
+
+} // namespace Common
@@ -40,6 +40,7 @@ void LogSettings() {
    LOG_INFO(Config, "yuzu Configuration:");
    log_setting("Controls_UseDockedMode", values.use_docked_mode.GetValue());
    log_setting("System_RngSeed", values.rng_seed.GetValue().value_or(0));
+    log_setting("System_DeviceName", values.device_name.GetValue());
    log_setting("System_CurrentUser", values.current_user.GetValue());
    log_setting("System_LanguageIndex", values.language_index.GetValue());
    log_setting("System_RegionIndex", values.region_index.GetValue());
@@ -128,6 +129,10 @@ void UpdateRescalingInfo() {
        info.up_scale = 1;
        info.down_shift = 0;
        break;
+    case ResolutionSetup::Res3_2X:
+        info.up_scale = 3;
+        info.down_shift = 1;
+        break;
    case ResolutionSetup::Res2X:
        info.up_scale = 2;
        info.down_shift = 0;
@@ -148,6 +153,14 @@ void UpdateRescalingInfo() {
        info.up_scale = 6;
        info.down_shift = 0;
        break;
+    case ResolutionSetup::Res7X:
+        info.up_scale = 7;
+        info.down_shift = 0;
+        break;
+    case ResolutionSetup::Res8X:
+        info.up_scale = 8;
+        info.down_shift = 0;
+        break;
    default:
        ASSERT(false);
        info.up_scale = 1;
@@ -184,6 +197,7 @@ void RestoreGlobalState(bool is_powered_on) {
    // Renderer
    values.fsr_sharpening_slider.SetGlobal(true);
    values.renderer_backend.SetGlobal(true);
+    values.renderer_force_max_clock.SetGlobal(true);
    values.vulkan_device.SetGlobal(true);
    values.aspect_ratio.SetGlobal(true);
    values.max_anisotropy.SetGlobal(true);
@@ -199,6 +213,7 @@ void RestoreGlobalState(bool is_powered_on) {
    values.use_asynchronous_shaders.SetGlobal(true);
    values.use_fast_gpu_time.SetGlobal(true);
    values.use_pessimistic_flushes.SetGlobal(true);
+    values.use_vulkan_driver_pipeline_cache.SetGlobal(true);
    values.bg_red.SetGlobal(true);
    values.bg_green.SetGlobal(true);
    values.bg_blue.SetGlobal(true);
@@ -56,11 +56,14 @@ enum class ResolutionSetup : u32 {
    Res1_2X = 0,
    Res3_4X = 1,
    Res1X = 2,
-    Res2X = 3,
-    Res3X = 4,
-    Res4X = 5,
-    Res5X = 6,
-    Res6X = 7,
+    Res3_2X = 3,
+    Res2X = 4,
+    Res3X = 5,
+    Res4X = 6,
+    Res5X = 7,
+    Res6X = 8,
+    Res7X = 9,
+    Res8X = 10,
 };

 enum class ScalingFilter : u32 {
@@ -76,7 +79,8 @@ enum class ScalingFilter : u32 {
 enum class AntiAliasing : u32 {
    None = 0,
    Fxaa = 1,
-    LastAA = Fxaa,
+    Smaa = 2,
+    LastAA = Smaa,
 };

 struct ResolutionScalingInfo {
@@ -414,6 +418,7 @@ struct Values {
    // Renderer
    SwitchableSetting<RendererBackend, true> renderer_backend{
        RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Null, "backend"};
+    SwitchableSetting<bool> renderer_force_max_clock{false, "force_max_clock"};
    Setting<bool> renderer_debug{false, "debug"};
    Setting<bool> renderer_shader_feedback{false, "shader_feedback"};
    Setting<bool> enable_nsight_aftermath{false, "nsight_aftermath"};
@@ -450,6 +455,8 @@ struct Values {
    SwitchableSetting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};
    SwitchableSetting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};
    SwitchableSetting<bool> use_pessimistic_flushes{false, "use_pessimistic_flushes"};
+    SwitchableSetting<bool> use_vulkan_driver_pipeline_cache{true,
+                                                             "use_vulkan_driver_pipeline_cache"};

    SwitchableSetting<u8> bg_red{0, "bg_red"};
    SwitchableSetting<u8> bg_green{0, "bg_green"};
@@ -457,6 +464,7 @@ struct Values {

    // System
    SwitchableSetting<std::optional<u32>> rng_seed{std::optional<u32>(), "rng_seed"};
+    Setting<std::string> device_name{"Yuzu", "device_name"};
    // Measured in seconds since epoch
    std::optional<s64> custom_rtc;
    // Set on game boot, reset on stop. Seconds difference between current time and `custom_rtc`
@@ -529,6 +537,7 @@ struct Values {
    Setting<bool> reporting_services{false, "reporting_services"};
    Setting<bool> quest_flag{false, "quest_flag"};
    Setting<bool> disable_macro_jit{false, "disable_macro_jit"};
+    Setting<bool> disable_macro_hle{false, "disable_macro_hle"};
    Setting<bool> extended_logging{false, "extended_logging"};
    Setting<bool> use_debug_asserts{false, "use_debug_asserts"};
    Setting<bool> use_auto_stub{false, "use_auto_stub"};
@@ -11,6 +11,7 @@
 #include <mutex>
 #include <thread>
 #include "common/common_types.h"
+#include "common/polyfill_thread.h"

 namespace Common {

@@ -69,7 +70,7 @@ public:
    explicit Barrier(std::size_t count_) : count(count_) {}

    /// Blocks until all "count" threads have called Sync()
-    void Sync() {
+    bool Sync(std::stop_token token = {}) {
        std::unique_lock lk{mutex};
        const std::size_t current_generation = generation;

@@ -77,14 +78,16 @@ public:
            generation++;
            waiting = 0;
            condvar.notify_all();
+            return true;
        } else {
-            condvar.wait(lk,
-                         [this, current_generation] { return current_generation != generation; });
+            CondvarWait(condvar, lk, token,
+                        [this, current_generation] { return current_generation != generation; });
+            return !token.stop_requested();
        }
    }

 private:
-    std::condition_variable condvar;
+    std::condition_variable_any condvar;
    std::mutex mutex;
    std::size_t count;
    std::size_t waiting = 0;
@@ -201,6 +201,9 @@ add_library(core STATIC
    hle/kernel/k_event_info.h
    hle/kernel/k_handle_table.cpp
    hle/kernel/k_handle_table.h
+    hle/kernel/k_hardware_timer_base.h
+    hle/kernel/k_hardware_timer.cpp
+    hle/kernel/k_hardware_timer.h
    hle/kernel/k_interrupt_manager.cpp
    hle/kernel/k_interrupt_manager.h
    hle/kernel/k_light_condition_variable.cpp
@@ -223,6 +226,7 @@ add_library(core STATIC
    hle/kernel/k_page_buffer.h
    hle/kernel/k_page_heap.cpp
    hle/kernel/k_page_heap.h
+    hle/kernel/k_page_group.cpp
    hle/kernel/k_page_group.h
    hle/kernel/k_page_table.cpp
    hle/kernel/k_page_table.h
@@ -268,6 +272,7 @@ add_library(core STATIC
    hle/kernel/k_thread_local_page.h
    hle/kernel/k_thread_queue.cpp
    hle/kernel/k_thread_queue.h
+    hle/kernel/k_timer_task.h
    hle/kernel/k_trace.h
    hle/kernel/k_transfer_memory.cpp
    hle/kernel/k_transfer_memory.h
@@ -290,8 +295,6 @@ add_library(core STATIC
    hle/kernel/svc_common.h
    hle/kernel/svc_types.h
    hle/kernel/svc_wrap.h
-    hle/kernel/time_manager.cpp
-    hle/kernel/time_manager.h
    hle/result.h
    hle/service/acc/acc.cpp
    hle/service/acc/acc.h
@@ -229,7 +229,11 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
    config.enable_cycle_counting = true;

    // Code cache size
+#ifdef ARCHITECTURE_arm64
+    config.code_cache_size = 128_MiB;
+#else
    config.code_cache_size = 512_MiB;
+#endif

    // Allow memory fault handling to work
    if (system.DebuggerEnabled()) {
@@ -288,7 +288,11 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
    config.enable_cycle_counting = true;

    // Code cache size
+#ifdef ARCHITECTURE_arm64
+    config.code_cache_size = 128_MiB;
+#else
    config.code_cache_size = 512_MiB;
+#endif

    // Allow memory fault handling to work
    if (system.DebuggerEnabled()) {
@@ -183,26 +183,20 @@ struct System::Impl {
        Initialize(system);
    }

-    SystemResultStatus Run() {
+    void Run() {
        std::unique_lock<std::mutex> lk(suspend_guard);
-        status = SystemResultStatus::Success;

        kernel.Suspend(false);
        core_timing.SyncPause(false);
        is_paused.store(false, std::memory_order_relaxed);
-
-        return status;
    }

-    SystemResultStatus Pause() {
+    void Pause() {
        std::unique_lock<std::mutex> lk(suspend_guard);
-        status = SystemResultStatus::Success;

        core_timing.SyncPause(true);
        kernel.Suspend(true);
        is_paused.store(true, std::memory_order_relaxed);
-
-        return status;
    }

    bool IsPaused() const {
@@ -389,7 +383,9 @@ struct System::Impl {
        kernel.ShutdownCores();
        cpu_manager.Shutdown();
        debugger.reset();
-        services->KillNVNFlinger();
+        if (services) {
+            services->KillNVNFlinger();
+        }
        kernel.CloseServices();
        services.reset();
        service_manager.reset();
@@ -551,12 +547,12 @@ void System::Initialize() {
    impl->Initialize(*this);
 }

-SystemResultStatus System::Run() {
-    return impl->Run();
+void System::Run() {
+    impl->Run();
 }

-SystemResultStatus System::Pause() {
-    return impl->Pause();
+void System::Pause() {
+    impl->Pause();
 }

 bool System::IsPaused() const {
@@ -152,13 +152,13 @@ public:
     * Run the OS and Application
     * This function will start emulation and run the relevant devices
     */
-    [[nodiscard]] SystemResultStatus Run();
+    void Run();

    /**
     * Pause the OS and Application
     * This function will pause emulation and stop the relevant devices
     */
-    [[nodiscard]] SystemResultStatus Pause();
+    void Pause();

    /// Check if the core is currently paused.
    [[nodiscard]] bool IsPaused() const;
@@ -142,16 +142,24 @@ void CoreTiming::ScheduleLoopingEvent(std::chrono::nanoseconds start_time,
 }

 void CoreTiming::UnscheduleEvent(const std::shared_ptr<EventType>& event_type,
-                                 std::uintptr_t user_data) {
-    std::scoped_lock scope{basic_lock};
-    const auto itr = std::remove_if(event_queue.begin(), event_queue.end(), [&](const Event& e) {
-        return e.type.lock().get() == event_type.get() && e.user_data == user_data;
-    });
+                                 std::uintptr_t user_data, bool wait) {
+    {
+        std::scoped_lock lk{basic_lock};
+        const auto itr =
+            std::remove_if(event_queue.begin(), event_queue.end(), [&](const Event& e) {
+                return e.type.lock().get() == event_type.get() && e.user_data == user_data;
+            });

-    // Removing random items breaks the invariant so we have to re-establish it.
-    if (itr != event_queue.end()) {
-        event_queue.erase(itr, event_queue.end());
-        std::make_heap(event_queue.begin(), event_queue.end(), std::greater<>());
+        // Removing random items breaks the invariant so we have to re-establish it.
+        if (itr != event_queue.end()) {
+            event_queue.erase(itr, event_queue.end());
+            std::make_heap(event_queue.begin(), event_queue.end(), std::greater<>());
+        }
+    }
+
+    // Force any in-progress events to finish
+    if (wait) {
+        std::scoped_lock lk{advance_lock};
    }
 }

@@ -190,20 +198,6 @@ u64 CoreTiming::GetClockTicks() const {
    return CpuCyclesToClockCycles(ticks);
 }

-void CoreTiming::RemoveEvent(const std::shared_ptr<EventType>& event_type) {
-    std::scoped_lock lock{basic_lock};
-
-    const auto itr = std::remove_if(event_queue.begin(), event_queue.end(), [&](const Event& e) {
-        return e.type.lock().get() == event_type.get();
-    });
-
-    // Removing random items breaks the invariant so we have to re-establish it.
-    if (itr != event_queue.end()) {
-        event_queue.erase(itr, event_queue.end());
-        std::make_heap(event_queue.begin(), event_queue.end(), std::greater<>());
-    }
-}
-
 std::optional<s64> CoreTiming::Advance() {
    std::scoped_lock lock{advance_lock, basic_lock};
    global_timer = GetGlobalTimeNs().count();
@@ -98,10 +98,13 @@ public:
                              const std::shared_ptr<EventType>& event_type,
                              std::uintptr_t user_data = 0, bool absolute_time = false);

-    void UnscheduleEvent(const std::shared_ptr<EventType>& event_type, std::uintptr_t user_data);
+    void UnscheduleEvent(const std::shared_ptr<EventType>& event_type, std::uintptr_t user_data,
+                         bool wait = true);

-    /// We only permit one event of each type in the queue at a time.
-    void RemoveEvent(const std::shared_ptr<EventType>& event_type);
+    void UnscheduleEventWithoutWait(const std::shared_ptr<EventType>& event_type,
+                                    std::uintptr_t user_data) {
+        UnscheduleEvent(event_type, user_data, false);
+    }

    void AddTicks(u64 ticks_to_add);

@@ -20,23 +20,20 @@ namespace Core {
 CpuManager::CpuManager(System& system_) : system{system_} {}
 CpuManager::~CpuManager() = default;

-void CpuManager::ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager,
-                             std::size_t core) {
-    cpu_manager.RunThread(core);
-}
-
 void CpuManager::Initialize() {
    num_cores = is_multicore ? Core::Hardware::NUM_CPU_CORES : 1;
    gpu_barrier = std::make_unique<Common::Barrier>(num_cores + 1);

    for (std::size_t core = 0; core < num_cores; core++) {
-        core_data[core].host_thread = std::jthread(ThreadStart, std::ref(*this), core);
+        core_data[core].host_thread =
+            std::jthread([this, core](std::stop_token token) { RunThread(token, core); });
    }
 }

 void CpuManager::Shutdown() {
    for (std::size_t core = 0; core < num_cores; core++) {
        if (core_data[core].host_thread.joinable()) {
+            core_data[core].host_thread.request_stop();
            core_data[core].host_thread.join();
        }
    }
@@ -184,7 +181,7 @@ void CpuManager::ShutdownThread() {
    UNREACHABLE();
 }

-void CpuManager::RunThread(std::size_t core) {
+void CpuManager::RunThread(std::stop_token token, std::size_t core) {
    /// Initialization
    system.RegisterCoreThread(core);
    std::string name;
@@ -206,7 +203,9 @@ void CpuManager::RunThread(std::size_t core) {
    });

    // Running
-    gpu_barrier->Sync();
+    if (!gpu_barrier->Sync(token)) {
+        return;
+    }

    if (!is_async_gpu && !is_multicore) {
        system.GPU().ObtainContext();
@@ -81,12 +81,10 @@ private:
    void SingleCoreRunGuestThread();
    void SingleCoreRunIdleThread();

-    static void ThreadStart(std::stop_token stop_token, CpuManager& cpu_manager, std::size_t core);
-
    void GuestActivate();
    void HandleInterrupt();
    void ShutdownThread();
-    void RunThread(std::size_t core);
+    void RunThread(std::stop_token stop_token, std::size_t core);

    struct CoreData {
        std::shared_ptr<Common::Fiber> host_context;
@@ -11,6 +11,7 @@
 #include "common/hex_util.h"
 #include "common/logging/log.h"
 #include "common/scope_exit.h"
+#include "common/settings.h"
 #include "core/arm/arm_interface.h"
 #include "core/core.h"
 #include "core/debugger/gdbstub.h"
@@ -731,7 +732,25 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
    auto* process = system.CurrentProcess();
    auto& page_table = process->PageTable();

-    if (command_str == "get info") {
+    const char* commands = "Commands:\n"
+                           "  get fastmem\n"
+                           "  get info\n"
+                           "  get mappings\n";
+
+    if (command_str == "get fastmem") {
+        if (Settings::IsFastmemEnabled()) {
+            const auto& impl = page_table.PageTableImpl();
+            const auto region = reinterpret_cast<uintptr_t>(impl.fastmem_arena);
+            const auto region_bits = impl.current_address_space_width_in_bits;
+            const auto region_size = 1ULL << region_bits;
+
+            reply = fmt::format("Region bits:  {}\n"
+                                "Host address: {:#x} - {:#x}\n",
+                                region_bits, region, region + region_size - 1);
+        } else {
+            reply = "Fastmem is not enabled.\n";
+        }
+    } else if (command_str == "get info") {
        Loader::AppLoader::Modules modules;
        system.GetAppLoader().ReadNSOModules(modules);

@@ -787,9 +806,10 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
            cur_addr = next_address;
        }
    } else if (command_str == "help") {
-        reply = "Commands:\n  get info\n  get mappings\n";
+        reply = commands;
    } else {
-        reply = "Unknown command.\nCommands:\n  get info\n  get mappings\n";
+        reply = "Unknown command.\n";
+        reply += commands;
    }

    std::span<const u8> reply_span{reinterpret_cast<u8*>(&reply.front()), reply.size()};
@@ -194,9 +194,9 @@ std::size_t VfsFile::WriteBytes(const std::vector<u8>& data, std::size_t offset)

 std::string VfsFile::GetFullPath() const {
    if (GetContainingDirectory() == nullptr)
-        return "/" + GetName();
+        return '/' + GetName();

-    return GetContainingDirectory()->GetFullPath() + "/" + GetName();
+    return GetContainingDirectory()->GetFullPath() + '/' + GetName();
 }

 VirtualFile VfsDirectory::GetFileRelative(std::string_view path) const {
@@ -435,7 +435,7 @@ std::string VfsDirectory::GetFullPath() const {
    if (IsRoot())
        return GetName();

-    return GetParentDirectory()->GetFullPath() + "/" + GetName();
+    return GetParentDirectory()->GetFullPath() + '/' + GetName();
 }

 bool ReadOnlyVfsDirectory::IsWritable() const {
@@ -131,6 +131,10 @@ public:
        return active_config;
    }

+    bool StrictContextRequired() const {
+        return strict_context_required;
+    }
+
    /**
     * Requests the internal configuration to be replaced by the specified argument at some point in
     * the future.
@@ -207,6 +211,8 @@ protected:

    WindowSystemInfo window_info;

+    bool strict_context_required = false;
+
 private:
    /**
     * Handler called when the minimal client area was requested to be changed via SetConfig.
@@ -40,6 +40,11 @@ void EmulatedConsole::SetTouchParams() {
        touch_params[index++] = std::move(touchscreen_param);
    }

+    if (Settings::values.touch_from_button_maps.empty()) {
+        LOG_WARNING(Input, "touch_from_button_maps is unset by frontend config");
+        return;
+    }
+
    const auto button_index =
        static_cast<u64>(Settings::values.touch_from_button_map_index.GetValue());
    const auto& touch_buttons = Settings::values.touch_from_button_maps[button_index].buttons;
@@ -11,6 +11,11 @@
 namespace Core::HID {
 constexpr s32 HID_JOYSTICK_MAX = 0x7fff;
 constexpr s32 HID_TRIGGER_MAX = 0x7fff;
+// Use a common UUID for TAS and Virtual Gamepad
+constexpr Common::UUID TAS_UUID =
+    Common::UUID{{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xA5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}};
+constexpr Common::UUID VIRTUAL_UUID =
+    Common::UUID{{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xFF, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}};

 EmulatedController::EmulatedController(NpadIdType npad_id_type_) : npad_id_type(npad_id_type_) {}

@@ -145,6 +150,7 @@ void EmulatedController::LoadDevices() {
    output_params[3].Set("output", true);

    LoadTASParams();
+    LoadVirtualGamepadParams();

    std::ranges::transform(button_params, button_devices.begin(), Common::Input::CreateInputDevice);
    std::ranges::transform(stick_params, stick_devices.begin(), Common::Input::CreateInputDevice);
@@ -163,6 +169,12 @@ void EmulatedController::LoadDevices() {
                           Common::Input::CreateInputDevice);
    std::ranges::transform(tas_stick_params, tas_stick_devices.begin(),
                           Common::Input::CreateInputDevice);
+
+    // Initialize virtual gamepad devices
+    std::ranges::transform(virtual_button_params, virtual_button_devices.begin(),
+                           Common::Input::CreateInputDevice);
+    std::ranges::transform(virtual_stick_params, virtual_stick_devices.begin(),
+                           Common::Input::CreateInputDevice);
 }

 void EmulatedController::LoadTASParams() {
@@ -203,6 +215,53 @@ void EmulatedController::LoadTASParams() {
    tas_stick_params[Settings::NativeAnalog::LStick].Set("axis_y", 1);
    tas_stick_params[Settings::NativeAnalog::RStick].Set("axis_x", 2);
    tas_stick_params[Settings::NativeAnalog::RStick].Set("axis_y", 3);
+
+    // set to optimal stick to avoid sanitizing the stick and tweaking the coordinates
+    // making sure they play back in the game as originally written down in the script file
+    tas_stick_params[Settings::NativeAnalog::LStick].Set("deadzone", 0.0f);
+    tas_stick_params[Settings::NativeAnalog::LStick].Set("range", 1.0f);
+    tas_stick_params[Settings::NativeAnalog::RStick].Set("deadzone", 0.0f);
+    tas_stick_params[Settings::NativeAnalog::RStick].Set("range", 1.0f);
+}
+
+void EmulatedController::LoadVirtualGamepadParams() {
+    const auto player_index = NpadIdTypeToIndex(npad_id_type);
+    Common::ParamPackage common_params{};
+    common_params.Set("engine", "virtual_gamepad");
+    common_params.Set("port", static_cast<int>(player_index));
+    for (auto& param : virtual_button_params) {
+        param = common_params;
+    }
+    for (auto& param : virtual_stick_params) {
+        param = common_params;
+    }
+
+    // TODO(german77): Replace this with an input profile or something better
+    virtual_button_params[Settings::NativeButton::A].Set("button", 0);
+    virtual_button_params[Settings::NativeButton::B].Set("button", 1);
+    virtual_button_params[Settings::NativeButton::X].Set("button", 2);
+    virtual_button_params[Settings::NativeButton::Y].Set("button", 3);
+    virtual_button_params[Settings::NativeButton::LStick].Set("button", 4);
+    virtual_button_params[Settings::NativeButton::RStick].Set("button", 5);
+    virtual_button_params[Settings::NativeButton::L].Set("button", 6);
+    virtual_button_params[Settings::NativeButton::R].Set("button", 7);
+    virtual_button_params[Settings::NativeButton::ZL].Set("button", 8);
+    virtual_button_params[Settings::NativeButton::ZR].Set("button", 9);
+    virtual_button_params[Settings::NativeButton::Plus].Set("button", 10);
+    virtual_button_params[Settings::NativeButton::Minus].Set("button", 11);
+    virtual_button_params[Settings::NativeButton::DLeft].Set("button", 12);
+    virtual_button_params[Settings::NativeButton::DUp].Set("button", 13);
+    virtual_button_params[Settings::NativeButton::DRight].Set("button", 14);
+    virtual_button_params[Settings::NativeButton::DDown].Set("button", 15);
+    virtual_button_params[Settings::NativeButton::SL].Set("button", 16);
+    virtual_button_params[Settings::NativeButton::SR].Set("button", 17);
+    virtual_button_params[Settings::NativeButton::Home].Set("button", 18);
+    virtual_button_params[Settings::NativeButton::Screenshot].Set("button", 19);
+
+    virtual_stick_params[Settings::NativeAnalog::LStick].Set("axis_x", 0);
+    virtual_stick_params[Settings::NativeAnalog::LStick].Set("axis_y", 1);
+    virtual_stick_params[Settings::NativeAnalog::RStick].Set("axis_x", 2);
+    virtual_stick_params[Settings::NativeAnalog::RStick].Set("axis_y", 3);
 }

 void EmulatedController::ReloadInput() {
@@ -294,10 +353,6 @@ void EmulatedController::ReloadInput() {
        }
    }

-    // Use a common UUID for TAS
-    static constexpr Common::UUID TAS_UUID = Common::UUID{
-        {0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x7, 0xA5, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}};
-
    // Register TAS devices. No need to force update
    for (std::size_t index = 0; index < tas_button_devices.size(); ++index) {
        if (!tas_button_devices[index]) {
@@ -322,6 +377,31 @@ void EmulatedController::ReloadInput() {
                },
        });
    }
+
+    // Register virtual devices. No need to force update
+    for (std::size_t index = 0; index < virtual_button_devices.size(); ++index) {
+        if (!virtual_button_devices[index]) {
+            continue;
+        }
+        virtual_button_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetButton(callback, index, VIRTUAL_UUID);
+                },
+        });
+    }
+
+    for (std::size_t index = 0; index < virtual_stick_devices.size(); ++index) {
+        if (!virtual_stick_devices[index]) {
+            continue;
+        }
+        virtual_stick_devices[index]->SetCallback({
+            .on_change =
+                [this, index](const Common::Input::CallbackStatus& callback) {
+                    SetStick(callback, index, VIRTUAL_UUID);
+                },
+        });
+    }
 }

 void EmulatedController::UnloadInput() {
@@ -349,6 +429,12 @@ void EmulatedController::UnloadInput() {
    for (auto& stick : tas_stick_devices) {
        stick.reset();
    }
+    for (auto& button : virtual_button_devices) {
+        button.reset();
+    }
+    for (auto& stick : virtual_stick_devices) {
+        stick.reset();
+    }
    camera_devices.reset();
    nfc_devices.reset();
 }
@@ -691,7 +777,12 @@ void EmulatedController::SetStick(const Common::Input::CallbackStatus& callback,

    // Only read stick values that have the same uuid or are over the threshold to avoid flapping
    if (controller.stick_values[index].uuid != uuid) {
-        if (!stick_value.down && !stick_value.up && !stick_value.left && !stick_value.right) {
+        const bool is_tas = uuid == TAS_UUID;
+        if (is_tas && stick_value.x.value == 0 && stick_value.y.value == 0) {
+            return;
+        }
+        if (!is_tas && !stick_value.down && !stick_value.up && !stick_value.left &&
+            !stick_value.right) {
            return;
        }
    }
@@ -1343,16 +1434,6 @@ AnalogSticks EmulatedController::GetSticks() const {
        return {};
    }

-    // Some drivers like stick from buttons need constant refreshing
-    for (auto& device : stick_devices) {
-        if (!device) {
-            continue;
-        }
-        lock.unlock();
-        device->SoftUpdate();
-        lock.lock();
-    }
-
    return controller.analog_stick_state;
 }

@@ -385,6 +385,9 @@ private:
    /// Set the params for TAS devices
    void LoadTASParams();

+    /// Set the params for virtual pad devices
+    void LoadVirtualGamepadParams();
+
    /**
     * @param use_temporary_value If true tmp_npad_type will be used
     * @return true if the controller style is fullkey
@@ -500,6 +503,12 @@ private:
    ButtonDevices tas_button_devices;
    StickDevices tas_stick_devices;

+    // Virtual gamepad related variables
+    ButtonParams virtual_button_params;
+    StickParams virtual_stick_params;
+    ButtonDevices virtual_button_devices;
+    StickDevices virtual_stick_devices;
+
    mutable std::mutex mutex;
    mutable std::mutex callback_mutex;
    std::unordered_map<int, ControllerUpdateCallback> callback_list;
@@ -167,6 +167,9 @@ void HLERequestContext::ParseCommandBuffer(const KHandleTable& handle_table, u32
        }
        if (incoming) {
            // Populate the object lists with the data in the IPC request.
+            incoming_copy_handles.reserve(handle_descriptor_header->num_handles_to_copy);
+            incoming_move_handles.reserve(handle_descriptor_header->num_handles_to_move);
+
            for (u32 handle = 0; handle < handle_descriptor_header->num_handles_to_copy; ++handle) {
                incoming_copy_handles.push_back(rp.Pop<Handle>());
            }
@@ -181,6 +184,11 @@ void HLERequestContext::ParseCommandBuffer(const KHandleTable& handle_table, u32
        }
    }

+    buffer_x_desciptors.reserve(command_header->num_buf_x_descriptors);
+    buffer_a_desciptors.reserve(command_header->num_buf_a_descriptors);
+    buffer_b_desciptors.reserve(command_header->num_buf_b_descriptors);
+    buffer_w_desciptors.reserve(command_header->num_buf_w_descriptors);
+
    for (u32 i = 0; i < command_header->num_buf_x_descriptors; ++i) {
        buffer_x_desciptors.push_back(rp.PopRaw<IPC::BufferDescriptorX>());
    }
@@ -318,25 +326,23 @@ Result HLERequestContext::WriteToOutgoingCommandBuffer(KThread& requesting_threa
 }

 std::vector<u8> HLERequestContext::ReadBuffer(std::size_t buffer_index) const {
-    std::vector<u8> buffer{};
    const bool is_buffer_a{BufferDescriptorA().size() > buffer_index &&
                           BufferDescriptorA()[buffer_index].Size()};
-
    if (is_buffer_a) {
        ASSERT_OR_EXECUTE_MSG(
-            BufferDescriptorA().size() > buffer_index, { return buffer; },
+            BufferDescriptorA().size() > buffer_index, { return {}; },
            "BufferDescriptorA invalid buffer_index {}", buffer_index);
-        buffer.resize(BufferDescriptorA()[buffer_index].Size());
+        std::vector<u8> buffer(BufferDescriptorA()[buffer_index].Size());
        memory.ReadBlock(BufferDescriptorA()[buffer_index].Address(), buffer.data(), buffer.size());
+        return buffer;
    } else {
        ASSERT_OR_EXECUTE_MSG(
-            BufferDescriptorX().size() > buffer_index, { return buffer; },
+            BufferDescriptorX().size() > buffer_index, { return {}; },
            "BufferDescriptorX invalid buffer_index {}", buffer_index);
-        buffer.resize(BufferDescriptorX()[buffer_index].Size());
+        std::vector<u8> buffer(BufferDescriptorX()[buffer_index].Size());
        memory.ReadBlock(BufferDescriptorX()[buffer_index].Address(), buffer.data(), buffer.size());
+        return buffer;
    }
-
-    return buffer;
 }

 std::size_t HLERequestContext::WriteBuffer(const void* buffer, std::size_t size,
@@ -10,7 +10,6 @@
 #include "core/hle/kernel/k_thread_queue.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/svc_results.h"
-#include "core/hle/kernel/time_manager.h"
 #include "core/memory.h"

 namespace Kernel {
@@ -27,13 +27,13 @@ Result KCodeMemory::Initialize(Core::DeviceMemory& device_memory, VAddr addr, si
    auto& page_table = m_owner->PageTable();

    // Construct the page group.
-    m_page_group = {};
+    m_page_group.emplace(kernel, page_table.GetBlockInfoManager());

    // Lock the memory.
-    R_TRY(page_table.LockForCodeMemory(&m_page_group, addr, size))
+    R_TRY(page_table.LockForCodeMemory(std::addressof(*m_page_group), addr, size))

    // Clear the memory.
-    for (const auto& block : m_page_group.Nodes()) {
+    for (const auto& block : *m_page_group) {
        std::memset(device_memory.GetPointer<void>(block.GetAddress()), 0xFF, block.GetSize());
    }

@@ -51,12 +51,13 @@ Result KCodeMemory::Initialize(Core::DeviceMemory& device_memory, VAddr addr, si
 void KCodeMemory::Finalize() {
    // Unlock.
    if (!m_is_mapped && !m_is_owner_mapped) {
-        const size_t size = m_page_group.GetNumPages() * PageSize;
-        m_owner->PageTable().UnlockForCodeMemory(m_address, size, m_page_group);
+        const size_t size = m_page_group->GetNumPages() * PageSize;
+        m_owner->PageTable().UnlockForCodeMemory(m_address, size, *m_page_group);
    }

    // Close the page group.
-    m_page_group = {};
+    m_page_group->Close();
+    m_page_group->Finalize();

    // Close our reference to our owner.
    m_owner->Close();
@@ -64,7 +65,7 @@ void KCodeMemory::Finalize() {

 Result KCodeMemory::Map(VAddr address, size_t size) {
    // Validate the size.
-    R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
+    R_UNLESS(m_page_group->GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);

    // Lock ourselves.
    KScopedLightLock lk(m_lock);
@@ -74,7 +75,7 @@ Result KCodeMemory::Map(VAddr address, size_t size) {

    // Map the memory.
    R_TRY(kernel.CurrentProcess()->PageTable().MapPages(
-        address, m_page_group, KMemoryState::CodeOut, KMemoryPermission::UserReadWrite));
+        address, *m_page_group, KMemoryState::CodeOut, KMemoryPermission::UserReadWrite));

    // Mark ourselves as mapped.
    m_is_mapped = true;
@@ -84,13 +85,13 @@ Result KCodeMemory::Map(VAddr address, size_t size) {

 Result KCodeMemory::Unmap(VAddr address, size_t size) {
    // Validate the size.
-    R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
+    R_UNLESS(m_page_group->GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);

    // Lock ourselves.
    KScopedLightLock lk(m_lock);

    // Unmap the memory.
-    R_TRY(kernel.CurrentProcess()->PageTable().UnmapPages(address, m_page_group,
+    R_TRY(kernel.CurrentProcess()->PageTable().UnmapPages(address, *m_page_group,
                                                          KMemoryState::CodeOut));

    // Mark ourselves as unmapped.
@@ -101,7 +102,7 @@ Result KCodeMemory::Unmap(VAddr address, size_t size) {

 Result KCodeMemory::MapToOwner(VAddr address, size_t size, Svc::MemoryPermission perm) {
    // Validate the size.
-    R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
+    R_UNLESS(m_page_group->GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);

    // Lock ourselves.
    KScopedLightLock lk(m_lock);
@@ -125,7 +126,7 @@ Result KCodeMemory::MapToOwner(VAddr address, size_t size, Svc::MemoryPermission

    // Map the memory.
    R_TRY(
-        m_owner->PageTable().MapPages(address, m_page_group, KMemoryState::GeneratedCode, k_perm));
+        m_owner->PageTable().MapPages(address, *m_page_group, KMemoryState::GeneratedCode, k_perm));

    // Mark ourselves as mapped.
    m_is_owner_mapped = true;
@@ -135,13 +136,13 @@ Result KCodeMemory::MapToOwner(VAddr address, size_t size, Svc::MemoryPermission

 Result KCodeMemory::UnmapFromOwner(VAddr address, size_t size) {
    // Validate the size.
-    R_UNLESS(m_page_group.GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);
+    R_UNLESS(m_page_group->GetNumPages() == Common::DivideUp(size, PageSize), ResultInvalidSize);

    // Lock ourselves.
    KScopedLightLock lk(m_lock);

    // Unmap the memory.
-    R_TRY(m_owner->PageTable().UnmapPages(address, m_page_group, KMemoryState::GeneratedCode));
+    R_TRY(m_owner->PageTable().UnmapPages(address, *m_page_group, KMemoryState::GeneratedCode));

    // Mark ourselves as unmapped.
    m_is_owner_mapped = false;
@@ -3,6 +3,8 @@

 #pragma once

+#include <optional>
+
 #include "common/common_types.h"
 #include "core/device_memory.h"
 #include "core/hle/kernel/k_auto_object.h"
@@ -49,11 +51,11 @@ public:
        return m_address;
    }
    size_t GetSize() const {
-        return m_is_initialized ? m_page_group.GetNumPages() * PageSize : 0;
+        return m_is_initialized ? m_page_group->GetNumPages() * PageSize : 0;
    }

 private:
-    KPageGroup m_page_group{};
+    std::optional<KPageGroup> m_page_group{};
    KProcess* m_owner{};
    VAddr m_address{};
    KLightLock m_lock;
@@ -0,0 +1,76 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/hle/kernel/k_hardware_timer.h"
+#include "core/hle/kernel/k_scheduler.h"
+
+namespace Kernel {
+
+void KHardwareTimer::Initialize() {
+    // Create the timing callback to register with CoreTiming.
+    m_event_type = Core::Timing::CreateEvent(
+        "KHardwareTimer::Callback", [](std::uintptr_t timer_handle, s64, std::chrono::nanoseconds) {
+            reinterpret_cast<KHardwareTimer*>(timer_handle)->DoTask();
+            return std::nullopt;
+        });
+}
+
+void KHardwareTimer::Finalize() {
+    m_kernel.System().CoreTiming().UnscheduleEvent(m_event_type, reinterpret_cast<uintptr_t>(this));
+    m_wakeup_time = std::numeric_limits<s64>::max();
+    m_event_type.reset();
+}
+
+void KHardwareTimer::DoTask() {
+    // Handle the interrupt.
+    {
+        KScopedSchedulerLock slk{m_kernel};
+        KScopedSpinLock lk(this->GetLock());
+
+        //! Ignore this event if needed.
+        if (!this->GetInterruptEnabled()) {
+            return;
+        }
+
+        // Disable the timer interrupt while we handle this.
+        this->DisableInterrupt();
+
+        if (const s64 next_time = this->DoInterruptTaskImpl(GetTick());
+            0 < next_time && next_time <= m_wakeup_time) {
+            // We have a next time, so we should set the time to interrupt and turn the interrupt
+            // on.
+            this->EnableInterrupt(next_time);
+        }
+    }
+
+    // Clear the timer interrupt.
+    // Kernel::GetInterruptManager().ClearInterrupt(KInterruptName_NonSecurePhysicalTimer,
+    //                                              GetCurrentCoreId());
+}
+
+void KHardwareTimer::EnableInterrupt(s64 wakeup_time) {
+    this->DisableInterrupt();
+
+    m_wakeup_time = wakeup_time;
+    m_kernel.System().CoreTiming().ScheduleEvent(std::chrono::nanoseconds{m_wakeup_time},
+                                                 m_event_type, reinterpret_cast<uintptr_t>(this),
+                                                 true);
+}
+
+void KHardwareTimer::DisableInterrupt() {
+    m_kernel.System().CoreTiming().UnscheduleEventWithoutWait(m_event_type,
+                                                              reinterpret_cast<uintptr_t>(this));
+    m_wakeup_time = std::numeric_limits<s64>::max();
+}
+
+s64 KHardwareTimer::GetTick() const {
+    return m_kernel.System().CoreTiming().GetGlobalTimeNs().count();
+}
+
+bool KHardwareTimer::GetInterruptEnabled() {
+    return m_wakeup_time != std::numeric_limits<s64>::max();
+}
+
+} // namespace Kernel
@@ -0,0 +1,54 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/kernel/k_hardware_timer_base.h"
+
+namespace Core::Timing {
+struct EventType;
+} // namespace Core::Timing
+
+namespace Kernel {
+
+class KHardwareTimer : /* public KInterruptTask, */ public KHardwareTimerBase {
+public:
+    explicit KHardwareTimer(KernelCore& kernel) : KHardwareTimerBase{kernel} {}
+
+    // Public API.
+    void Initialize();
+    void Finalize();
+
+    s64 GetCount() const {
+        return GetTick();
+    }
+
+    void RegisterTask(KTimerTask* task, s64 time_from_now) {
+        this->RegisterAbsoluteTask(task, GetTick() + time_from_now);
+    }
+
+    void RegisterAbsoluteTask(KTimerTask* task, s64 task_time) {
+        KScopedDisableDispatch dd{m_kernel};
+        KScopedSpinLock lk{this->GetLock()};
+
+        if (this->RegisterAbsoluteTaskImpl(task, task_time)) {
+            if (task_time <= m_wakeup_time) {
+                this->EnableInterrupt(task_time);
+            }
+        }
+    }
+
+private:
+    void EnableInterrupt(s64 wakeup_time);
+    void DisableInterrupt();
+    bool GetInterruptEnabled();
+    s64 GetTick() const;
+    void DoTask();
+
+private:
+    // Absolute time in nanoseconds
+    s64 m_wakeup_time{std::numeric_limits<s64>::max()};
+    std::shared_ptr<Core::Timing::EventType> m_event_type{};
+};
+
+} // namespace Kernel
@@ -0,0 +1,92 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/kernel/k_spin_lock.h"
+#include "core/hle/kernel/k_thread.h"
+#include "core/hle/kernel/k_timer_task.h"
+
+namespace Kernel {
+
+class KHardwareTimerBase {
+public:
+    explicit KHardwareTimerBase(KernelCore& kernel) : m_kernel{kernel} {}
+
+    void CancelTask(KTimerTask* task) {
+        KScopedDisableDispatch dd{m_kernel};
+        KScopedSpinLock lk{m_lock};
+
+        if (const s64 task_time = task->GetTime(); task_time > 0) {
+            this->RemoveTaskFromTree(task);
+        }
+    }
+
+protected:
+    KSpinLock& GetLock() {
+        return m_lock;
+    }
+
+    s64 DoInterruptTaskImpl(s64 cur_time) {
+        // We want to handle all tasks, returning the next time that a task is scheduled.
+        while (true) {
+            // Get the next task. If there isn't one, return 0.
+            KTimerTask* task = m_next_task;
+            if (task == nullptr) {
+                return 0;
+            }
+
+            // If the task needs to be done in the future, do it in the future and not now.
+            if (const s64 task_time = task->GetTime(); task_time > cur_time) {
+                return task_time;
+            }
+
+            // Remove the task from the tree of tasks, and update our next task.
+            this->RemoveTaskFromTree(task);
+
+            // Handle the task.
+            task->OnTimer();
+        }
+    }
+
+    bool RegisterAbsoluteTaskImpl(KTimerTask* task, s64 task_time) {
+        ASSERT(task_time > 0);
+
+        // Set the task's time, and insert it into our tree.
+        task->SetTime(task_time);
+        m_task_tree.insert(*task);
+
+        // Update our next task if relevant.
+        if (m_next_task != nullptr && m_next_task->GetTime() <= task_time) {
+            return false;
+        }
+        m_next_task = task;
+        return true;
+    }
+
+private:
+    void RemoveTaskFromTree(KTimerTask* task) {
+        // Erase from the tree.
+        auto it = m_task_tree.erase(m_task_tree.iterator_to(*task));
+
+        // Clear the task's scheduled time.
+        task->SetTime(0);
+
+        // Update our next task if relevant.
+        if (m_next_task == task) {
+            m_next_task = (it != m_task_tree.end()) ? std::addressof(*it) : nullptr;
+        }
+    }
+
+protected:
+    KernelCore& m_kernel;
+
+private:
+    using TimerTaskTree = Common::IntrusiveRedBlackTreeBaseTraits<KTimerTask>::TreeType<KTimerTask>;
+
+    KSpinLock m_lock{};
+    TimerTaskTree m_task_tree{};
+    KTimerTask* m_next_task{};
+};
+
+} // namespace Kernel
@@ -223,7 +223,7 @@ Result KMemoryManager::AllocatePageGroupImpl(KPageGroup* out, size_t num_pages,

    // Ensure that we don't leave anything un-freed.
    ON_RESULT_FAILURE {
-        for (const auto& it : out->Nodes()) {
+        for (const auto& it : *out) {
            auto& manager = this->GetManager(it.GetAddress());
            const size_t node_num_pages = std::min<u64>(
                it.GetNumPages(), (manager.GetEndAddress() - it.GetAddress()) / PageSize);
@@ -285,7 +285,7 @@ Result KMemoryManager::AllocateAndOpen(KPageGroup* out, size_t num_pages, u32 op
                                      m_has_optimized_process[static_cast<size_t>(pool)], true));

    // Open the first reference to the pages.
-    for (const auto& block : out->Nodes()) {
+    for (const auto& block : *out) {
        PAddr cur_address = block.GetAddress();
        size_t remaining_pages = block.GetNumPages();
        while (remaining_pages > 0) {
@@ -335,7 +335,7 @@ Result KMemoryManager::AllocateForProcess(KPageGroup* out, size_t num_pages, u32
    // Perform optimized memory tracking, if we should.
    if (optimized) {
        // Iterate over the allocated blocks.
-        for (const auto& block : out->Nodes()) {
+        for (const auto& block : *out) {
            // Get the block extents.
            const PAddr block_address = block.GetAddress();
            const size_t block_pages = block.GetNumPages();
@@ -391,7 +391,7 @@ Result KMemoryManager::AllocateForProcess(KPageGroup* out, size_t num_pages, u32
        }
    } else {
        // Set all the allocated memory.
-        for (const auto& block : out->Nodes()) {
+        for (const auto& block : *out) {
            std::memset(m_system.DeviceMemory().GetPointer<void>(block.GetAddress()), fill_pattern,
                        block.GetSize());
        }
@@ -0,0 +1,121 @@
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/kernel/k_dynamic_resource_manager.h"
+#include "core/hle/kernel/k_memory_manager.h"
+#include "core/hle/kernel/k_page_group.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/svc_results.h"
+
+namespace Kernel {
+
+void KPageGroup::Finalize() {
+    KBlockInfo* cur = m_first_block;
+    while (cur != nullptr) {
+        KBlockInfo* next = cur->GetNext();
+        m_manager->Free(cur);
+        cur = next;
+    }
+
+    m_first_block = nullptr;
+    m_last_block = nullptr;
+}
+
+void KPageGroup::CloseAndReset() {
+    auto& mm = m_kernel.MemoryManager();
+
+    KBlockInfo* cur = m_first_block;
+    while (cur != nullptr) {
+        KBlockInfo* next = cur->GetNext();
+        mm.Close(cur->GetAddress(), cur->GetNumPages());
+        m_manager->Free(cur);
+        cur = next;
+    }
+
+    m_first_block = nullptr;
+    m_last_block = nullptr;
+}
+
+size_t KPageGroup::GetNumPages() const {
+    size_t num_pages = 0;
+
+    for (const auto& it : *this) {
+        num_pages += it.GetNumPages();
+    }
+
+    return num_pages;
+}
+
+Result KPageGroup::AddBlock(KPhysicalAddress addr, size_t num_pages) {
+    // Succeed immediately if we're adding no pages.
+    R_SUCCEED_IF(num_pages == 0);
+
+    // Check for overflow.
+    ASSERT(addr < addr + num_pages * PageSize);
+
+    // Try to just append to the last block.
+    if (m_last_block != nullptr) {
+        R_SUCCEED_IF(m_last_block->TryConcatenate(addr, num_pages));
+    }
+
+    // Allocate a new block.
+    KBlockInfo* new_block = m_manager->Allocate();
+    R_UNLESS(new_block != nullptr, ResultOutOfResource);
+
+    // Initialize the block.
+    new_block->Initialize(addr, num_pages);
+
+    // Add the block to our list.
+    if (m_last_block != nullptr) {
+        m_last_block->SetNext(new_block);
+    } else {
+        m_first_block = new_block;
+    }
+    m_last_block = new_block;
+
+    R_SUCCEED();
+}
+
+void KPageGroup::Open() const {
+    auto& mm = m_kernel.MemoryManager();
+
+    for (const auto& it : *this) {
+        mm.Open(it.GetAddress(), it.GetNumPages());
+    }
+}
+
+void KPageGroup::OpenFirst() const {
+    auto& mm = m_kernel.MemoryManager();
+
+    for (const auto& it : *this) {
+        mm.OpenFirst(it.GetAddress(), it.GetNumPages());
+    }
+}
+
+void KPageGroup::Close() const {
+    auto& mm = m_kernel.MemoryManager();
+
+    for (const auto& it : *this) {
+        mm.Close(it.GetAddress(), it.GetNumPages());
+    }
+}
+
+bool KPageGroup::IsEquivalentTo(const KPageGroup& rhs) const {
+    auto lit = this->begin();
+    auto rit = rhs.begin();
+    auto lend = this->end();
+    auto rend = rhs.end();
+
+    while (lit != lend && rit != rend) {
+        if (*lit != *rit) {
+            return false;
+        }
+
+        ++lit;
+        ++rit;
+    }
+
+    return lit == lend && rit == rend;
+}
+
+} // namespace Kernel
@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

 #pragma once
@@ -13,24 +13,23 @@

 namespace Kernel {

+class KBlockInfoManager;
+class KernelCore;
 class KPageGroup;

 class KBlockInfo {
-private:
-    friend class KPageGroup;
-
 public:
-    constexpr KBlockInfo() = default;
+    constexpr explicit KBlockInfo() : m_next(nullptr) {}

-    constexpr void Initialize(PAddr addr, size_t np) {
+    constexpr void Initialize(KPhysicalAddress addr, size_t np) {
        ASSERT(Common::IsAligned(addr, PageSize));
        ASSERT(static_cast<u32>(np) == np);

-        m_page_index = static_cast<u32>(addr) / PageSize;
+        m_page_index = static_cast<u32>(addr / PageSize);
        m_num_pages = static_cast<u32>(np);
    }

-    constexpr PAddr GetAddress() const {
+    constexpr KPhysicalAddress GetAddress() const {
        return m_page_index * PageSize;
    }
    constexpr size_t GetNumPages() const {
@@ -39,10 +38,10 @@ public:
    constexpr size_t GetSize() const {
        return this->GetNumPages() * PageSize;
    }
-    constexpr PAddr GetEndAddress() const {
+    constexpr KPhysicalAddress GetEndAddress() const {
        return (m_page_index + m_num_pages) * PageSize;
    }
-    constexpr PAddr GetLastAddress() const {
+    constexpr KPhysicalAddress GetLastAddress() const {
        return this->GetEndAddress() - 1;
    }

@@ -62,8 +61,8 @@ public:
        return !(*this == rhs);
    }

-    constexpr bool IsStrictlyBefore(PAddr addr) const {
-        const PAddr end = this->GetEndAddress();
+    constexpr bool IsStrictlyBefore(KPhysicalAddress addr) const {
+        const KPhysicalAddress end = this->GetEndAddress();

        if (m_page_index != 0 && end == 0) {
            return false;
@@ -72,11 +71,11 @@ public:
        return end < addr;
    }

-    constexpr bool operator<(PAddr addr) const {
+    constexpr bool operator<(KPhysicalAddress addr) const {
        return this->IsStrictlyBefore(addr);
    }

-    constexpr bool TryConcatenate(PAddr addr, size_t np) {
+    constexpr bool TryConcatenate(KPhysicalAddress addr, size_t np) {
        if (addr != 0 && addr == this->GetEndAddress()) {
            m_num_pages += static_cast<u32>(np);
            return true;
@@ -90,96 +89,118 @@ private:
    }

 private:
+    friend class KPageGroup;
+
    KBlockInfo* m_next{};
    u32 m_page_index{};
    u32 m_num_pages{};
 };
 static_assert(sizeof(KBlockInfo) <= 0x10);

-class KPageGroup final {
+class KPageGroup {
 public:
-    class Node final {
+    class Iterator {
    public:
-        constexpr Node(u64 addr_, std::size_t num_pages_) : addr{addr_}, num_pages{num_pages_} {}
+        using iterator_category = std::forward_iterator_tag;
+        using value_type = const KBlockInfo;
+        using difference_type = std::ptrdiff_t;
+        using pointer = value_type*;
+        using reference = value_type&;

-        constexpr u64 GetAddress() const {
-            return addr;
+        constexpr explicit Iterator(pointer n) : m_node(n) {}
+
+        constexpr bool operator==(const Iterator& rhs) const {
+            return m_node == rhs.m_node;
+        }
+        constexpr bool operator!=(const Iterator& rhs) const {
+            return !(*this == rhs);
        }

-        constexpr std::size_t GetNumPages() const {
-            return num_pages;
+        constexpr pointer operator->() const {
+            return m_node;
+        }
+        constexpr reference operator*() const {
+            return *m_node;
        }

-        constexpr std::size_t GetSize() const {
-            return GetNumPages() * PageSize;
+        constexpr Iterator& operator++() {
+            m_node = m_node->GetNext();
+            return *this;
+        }
+
+        constexpr Iterator operator++(int) {
+            const Iterator it{*this};
+            ++(*this);
+            return it;
        }

    private:
-        u64 addr{};
-        std::size_t num_pages{};
+        pointer m_node{};
    };

-public:
-    KPageGroup() = default;
-    KPageGroup(u64 address, u64 num_pages) {
-        ASSERT(AddBlock(address, num_pages).IsSuccess());
+    explicit KPageGroup(KernelCore& kernel, KBlockInfoManager* m)
+        : m_kernel{kernel}, m_manager{m} {}
+    ~KPageGroup() {
+        this->Finalize();
    }

-    constexpr std::list<Node>& Nodes() {
-        return nodes;
+    void CloseAndReset();
+    void Finalize();
+
+    Iterator begin() const {
+        return Iterator{m_first_block};
+    }
+    Iterator end() const {
+        return Iterator{nullptr};
+    }
+    bool empty() const {
+        return m_first_block == nullptr;
    }

-    constexpr const std::list<Node>& Nodes() const {
-        return nodes;
+    Result AddBlock(KPhysicalAddress addr, size_t num_pages);
+    void Open() const;
+    void OpenFirst() const;
+    void Close() const;
+
+    size_t GetNumPages() const;
+
+    bool IsEquivalentTo(const KPageGroup& rhs) const;
+
+    bool operator==(const KPageGroup& rhs) const {
+        return this->IsEquivalentTo(rhs);
    }

-    std::size_t GetNumPages() const {
-        std::size_t num_pages = 0;
-        for (const Node& node : nodes) {
-            num_pages += node.GetNumPages();
-        }
-        return num_pages;
+    bool operator!=(const KPageGroup& rhs) const {
+        return !(*this == rhs);
    }

-    bool IsEqual(KPageGroup& other) const {
-        auto this_node = nodes.begin();
-        auto other_node = other.nodes.begin();
-        while (this_node != nodes.end() && other_node != other.nodes.end()) {
-            if (this_node->GetAddress() != other_node->GetAddress() ||
-                this_node->GetNumPages() != other_node->GetNumPages()) {
-                return false;
-            }
-            this_node = std::next(this_node);
-            other_node = std::next(other_node);
-        }
-
-        return this_node == nodes.end() && other_node == other.nodes.end();
-    }
-
-    Result AddBlock(u64 address, u64 num_pages) {
-        if (!num_pages) {
-            return ResultSuccess;
-        }
-        if (!nodes.empty()) {
-            const auto node = nodes.back();
-            if (node.GetAddress() + node.GetNumPages() * PageSize == address) {
-                address = node.GetAddress();
-                num_pages += node.GetNumPages();
-                nodes.pop_back();
-            }
-        }
-        nodes.push_back({address, num_pages});
-        return ResultSuccess;
-    }
-
-    bool Empty() const {
-        return nodes.empty();
-    }
-
-    void Finalize() {}
-
 private:
-    std::list<Node> nodes;
+    KernelCore& m_kernel;
+    KBlockInfo* m_first_block{};
+    KBlockInfo* m_last_block{};
+    KBlockInfoManager* m_manager{};
+};
+
+class KScopedPageGroup {
+public:
+    explicit KScopedPageGroup(const KPageGroup* gp) : m_pg(gp) {
+        if (m_pg) {
+            m_pg->Open();
+        }
+    }
+    explicit KScopedPageGroup(const KPageGroup& gp) : KScopedPageGroup(std::addressof(gp)) {}
+    ~KScopedPageGroup() {
+        if (m_pg) {
+            m_pg->Close();
+        }
+    }
+
+    void CancelClose() {
+        m_pg = nullptr;
+    }
+
+private:
+    const KPageGroup* m_pg{};
 };

 } // namespace Kernel
@@ -100,7 +100,7 @@ constexpr size_t GetAddressSpaceWidthFromType(FileSys::ProgramAddressSpaceType a

 KPageTable::KPageTable(Core::System& system_)
    : m_general_lock{system_.Kernel()},
-      m_map_physical_memory_lock{system_.Kernel()}, m_system{system_} {}
+      m_map_physical_memory_lock{system_.Kernel()}, m_system{system_}, m_kernel{system_.Kernel()} {}

 KPageTable::~KPageTable() = default;

@@ -373,7 +373,7 @@ Result KPageTable::MapProcessCode(VAddr addr, size_t num_pages, KMemoryState sta
                                                 m_memory_block_slab_manager);

    // Allocate and open.
-    KPageGroup pg;
+    KPageGroup pg{m_kernel, m_block_info_manager};
    R_TRY(m_system.Kernel().MemoryManager().AllocateAndOpen(
        &pg, num_pages,
        KMemoryManager::EncodeOption(KMemoryManager::Pool::Application, m_allocation_option)));
@@ -432,7 +432,7 @@ Result KPageTable::MapCodeMemory(VAddr dst_address, VAddr src_address, size_t si
        const size_t num_pages = size / PageSize;

        // Create page groups for the memory being mapped.
-        KPageGroup pg;
+        KPageGroup pg{m_kernel, m_block_info_manager};
        AddRegionToPages(src_address, num_pages, pg);

        // Reprotect the source as kernel-read/not mapped.
@@ -593,7 +593,7 @@ Result KPageTable::MakePageGroup(KPageGroup& pg, VAddr addr, size_t num_pages) {
    const size_t size = num_pages * PageSize;

    // We're making a new group, not adding to an existing one.
-    R_UNLESS(pg.Empty(), ResultInvalidCurrentMemory);
+    R_UNLESS(pg.empty(), ResultInvalidCurrentMemory);

    // Begin traversal.
    Common::PageTable::TraversalContext context;
@@ -640,11 +640,10 @@ Result KPageTable::MakePageGroup(KPageGroup& pg, VAddr addr, size_t num_pages) {
    R_SUCCEED();
 }

-bool KPageTable::IsValidPageGroup(const KPageGroup& pg_ll, VAddr addr, size_t num_pages) {
+bool KPageTable::IsValidPageGroup(const KPageGroup& pg, VAddr addr, size_t num_pages) {
    ASSERT(this->IsLockedByCurrentThread());

    const size_t size = num_pages * PageSize;
-    const auto& pg = pg_ll.Nodes();
    const auto& memory_layout = m_system.Kernel().MemoryLayout();

    // Empty groups are necessarily invalid.
@@ -942,9 +941,6 @@ Result KPageTable::SetupForIpcServer(VAddr* out_addr, size_t size, VAddr src_add

    ON_RESULT_FAILURE {
        if (cur_mapped_addr != dst_addr) {
-            // HACK: Manually close the pages.
-            HACK_ClosePages(dst_addr, (cur_mapped_addr - dst_addr) / PageSize);
-
            ASSERT(Operate(dst_addr, (cur_mapped_addr - dst_addr) / PageSize,
                           KMemoryPermission::None, OperationType::Unmap)
                       .IsSuccess());
@@ -1020,9 +1016,6 @@ Result KPageTable::SetupForIpcServer(VAddr* out_addr, size_t size, VAddr src_add
        // Map the page.
        R_TRY(Operate(cur_mapped_addr, 1, test_perm, OperationType::Map, start_partial_page));

-        // HACK: Manually open the pages.
-        HACK_OpenPages(start_partial_page, 1);
-
        // Update tracking extents.
        cur_mapped_addr += PageSize;
        cur_block_addr += PageSize;
@@ -1051,9 +1044,6 @@ Result KPageTable::SetupForIpcServer(VAddr* out_addr, size_t size, VAddr src_add
            R_TRY(Operate(cur_mapped_addr, cur_block_size / PageSize, test_perm, OperationType::Map,
                          cur_block_addr));

-            // HACK: Manually open the pages.
-            HACK_OpenPages(cur_block_addr, cur_block_size / PageSize);
-
            // Update tracking extents.
            cur_mapped_addr += cur_block_size;
            cur_block_addr = next_entry.phys_addr;
@@ -1073,9 +1063,6 @@ Result KPageTable::SetupForIpcServer(VAddr* out_addr, size_t size, VAddr src_add
        R_TRY(Operate(cur_mapped_addr, last_block_size / PageSize, test_perm, OperationType::Map,
                      cur_block_addr));

-        // HACK: Manually open the pages.
-        HACK_OpenPages(cur_block_addr, last_block_size / PageSize);
-
        // Update tracking extents.
        cur_mapped_addr += last_block_size;
        cur_block_addr += last_block_size;
@@ -1107,9 +1094,6 @@ Result KPageTable::SetupForIpcServer(VAddr* out_addr, size_t size, VAddr src_add

        // Map the page.
        R_TRY(Operate(cur_mapped_addr, 1, test_perm, OperationType::Map, end_partial_page));
-
-        // HACK: Manually open the pages.
-        HACK_OpenPages(end_partial_page, 1);
    }

    // Update memory blocks to reflect our changes
@@ -1211,9 +1195,6 @@ Result KPageTable::CleanupForIpcServer(VAddr address, size_t size, KMemoryState
    const size_t aligned_size = aligned_end - aligned_start;
    const size_t aligned_num_pages = aligned_size / PageSize;

-    // HACK: Manually close the pages.
-    HACK_ClosePages(aligned_start, aligned_num_pages);
-
    // Unmap the pages.
    R_TRY(Operate(aligned_start, aligned_num_pages, KMemoryPermission::None, OperationType::Unmap));

@@ -1501,17 +1482,6 @@ void KPageTable::CleanupForIpcClientOnServerSetupFailure([[maybe_unused]] PageLi
    }
 }

-void KPageTable::HACK_OpenPages(PAddr phys_addr, size_t num_pages) {
-    m_system.Kernel().MemoryManager().OpenFirst(phys_addr, num_pages);
-}
-
-void KPageTable::HACK_ClosePages(VAddr virt_addr, size_t num_pages) {
-    for (size_t index = 0; index < num_pages; ++index) {
-        const auto paddr = GetPhysicalAddr(virt_addr + (index * PageSize));
-        m_system.Kernel().MemoryManager().Close(paddr, 1);
-    }
-}
-
 Result KPageTable::MapPhysicalMemory(VAddr address, size_t size) {
    // Lock the physical memory lock.
    KScopedLightLock phys_lk(m_map_physical_memory_lock);
@@ -1572,7 +1542,7 @@ Result KPageTable::MapPhysicalMemory(VAddr address, size_t size) {
            R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);

            // Allocate pages for the new memory.
-            KPageGroup pg;
+            KPageGroup pg{m_kernel, m_block_info_manager};
            R_TRY(m_system.Kernel().MemoryManager().AllocateForProcess(
                &pg, (size - mapped_size) / PageSize, m_allocate_option, 0, 0));

@@ -1650,7 +1620,7 @@ Result KPageTable::MapPhysicalMemory(VAddr address, size_t size) {
                KScopedPageTableUpdater updater(this);

                // Prepare to iterate over the memory.
-                auto pg_it = pg.Nodes().begin();
+                auto pg_it = pg.begin();
                PAddr pg_phys_addr = pg_it->GetAddress();
                size_t pg_pages = pg_it->GetNumPages();

@@ -1680,9 +1650,6 @@ Result KPageTable::MapPhysicalMemory(VAddr address, size_t size) {
                                             last_unmap_address + 1 - cur_address) /
                                    PageSize;

-                                // HACK: Manually close the pages.
-                                HACK_ClosePages(cur_address, cur_pages);
-
                                // Unmap.
                                ASSERT(Operate(cur_address, cur_pages, KMemoryPermission::None,
                                               OperationType::Unmap)
@@ -1703,7 +1670,7 @@ Result KPageTable::MapPhysicalMemory(VAddr address, size_t size) {
                    // Release any remaining unmapped memory.
                    m_system.Kernel().MemoryManager().OpenFirst(pg_phys_addr, pg_pages);
                    m_system.Kernel().MemoryManager().Close(pg_phys_addr, pg_pages);
-                    for (++pg_it; pg_it != pg.Nodes().end(); ++pg_it) {
+                    for (++pg_it; pg_it != pg.end(); ++pg_it) {
                        m_system.Kernel().MemoryManager().OpenFirst(pg_it->GetAddress(),
                                                                    pg_it->GetNumPages());
                        m_system.Kernel().MemoryManager().Close(pg_it->GetAddress(),
@@ -1731,7 +1698,7 @@ Result KPageTable::MapPhysicalMemory(VAddr address, size_t size) {
                            // Check if we're at the end of the physical block.
                            if (pg_pages == 0) {
                                // Ensure there are more pages to map.
-                                ASSERT(pg_it != pg.Nodes().end());
+                                ASSERT(pg_it != pg.end());

                                // Advance our physical block.
                                ++pg_it;
@@ -1742,10 +1709,7 @@ Result KPageTable::MapPhysicalMemory(VAddr address, size_t size) {
                            // Map whatever we can.
                            const size_t cur_pages = std::min(pg_pages, map_pages);
                            R_TRY(Operate(cur_address, cur_pages, KMemoryPermission::UserReadWrite,
-                                          OperationType::Map, pg_phys_addr));
-
-                            // HACK: Manually open the pages.
-                            HACK_OpenPages(pg_phys_addr, cur_pages);
+                                          OperationType::MapFirst, pg_phys_addr));

                            // Advance.
                            cur_address += cur_pages * PageSize;
@@ -1888,9 +1852,6 @@ Result KPageTable::UnmapPhysicalMemory(VAddr address, size_t size) {
                                              last_address + 1 - cur_address) /
                                     PageSize;

-            // HACK: Manually close the pages.
-            HACK_ClosePages(cur_address, cur_pages);
-
            // Unmap.
            ASSERT(Operate(cur_address, cur_pages, KMemoryPermission::None, OperationType::Unmap)
                       .IsSuccess());
@@ -1955,7 +1916,7 @@ Result KPageTable::MapMemory(VAddr dst_address, VAddr src_address, size_t size)
    R_TRY(dst_allocator_result);

    // Map the memory.
-    KPageGroup page_linked_list;
+    KPageGroup page_linked_list{m_kernel, m_block_info_manager};
    const size_t num_pages{size / PageSize};
    const KMemoryPermission new_src_perm = static_cast<KMemoryPermission>(
        KMemoryPermission::KernelRead | KMemoryPermission::NotMapped);
@@ -2022,14 +1983,14 @@ Result KPageTable::UnmapMemory(VAddr dst_address, VAddr src_address, size_t size
                                                     num_dst_allocator_blocks);
    R_TRY(dst_allocator_result);

-    KPageGroup src_pages;
-    KPageGroup dst_pages;
+    KPageGroup src_pages{m_kernel, m_block_info_manager};
+    KPageGroup dst_pages{m_kernel, m_block_info_manager};
    const size_t num_pages{size / PageSize};

    AddRegionToPages(src_address, num_pages, src_pages);
    AddRegionToPages(dst_address, num_pages, dst_pages);

-    R_UNLESS(dst_pages.IsEqual(src_pages), ResultInvalidMemoryRegion);
+    R_UNLESS(dst_pages.IsEquivalentTo(src_pages), ResultInvalidMemoryRegion);

    {
        auto block_guard = detail::ScopeExit([&] { MapPages(dst_address, dst_pages, dst_perm); });
@@ -2060,7 +2021,7 @@ Result KPageTable::MapPages(VAddr addr, const KPageGroup& page_linked_list,

    VAddr cur_addr{addr};

-    for (const auto& node : page_linked_list.Nodes()) {
+    for (const auto& node : page_linked_list) {
        if (const auto result{
                Operate(cur_addr, node.GetNumPages(), perm, OperationType::Map, node.GetAddress())};
            result.IsError()) {
@@ -2160,7 +2121,7 @@ Result KPageTable::UnmapPages(VAddr addr, const KPageGroup& page_linked_list) {

    VAddr cur_addr{addr};

-    for (const auto& node : page_linked_list.Nodes()) {
+    for (const auto& node : page_linked_list) {
        if (const auto result{Operate(cur_addr, node.GetNumPages(), KMemoryPermission::None,
                                      OperationType::Unmap)};
            result.IsError()) {
@@ -2527,13 +2488,13 @@ Result KPageTable::SetHeapSize(VAddr* out, size_t size) {
    R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);

    // Allocate pages for the heap extension.
-    KPageGroup pg;
+    KPageGroup pg{m_kernel, m_block_info_manager};
    R_TRY(m_system.Kernel().MemoryManager().AllocateAndOpen(
        &pg, allocation_size / PageSize,
        KMemoryManager::EncodeOption(m_memory_pool, m_allocation_option)));

    // Clear all the newly allocated pages.
-    for (const auto& it : pg.Nodes()) {
+    for (const auto& it : pg) {
        std::memset(m_system.DeviceMemory().GetPointer<void>(it.GetAddress()), m_heap_fill_value,
                    it.GetSize());
    }
@@ -2610,11 +2571,23 @@ ResultVal<VAddr> KPageTable::AllocateAndMapMemory(size_t needed_num_pages, size_
    if (is_map_only) {
        R_TRY(Operate(addr, needed_num_pages, perm, OperationType::Map, map_addr));
    } else {
-        KPageGroup page_group;
-        R_TRY(m_system.Kernel().MemoryManager().AllocateForProcess(
-            &page_group, needed_num_pages,
-            KMemoryManager::EncodeOption(m_memory_pool, m_allocation_option), 0, 0));
-        R_TRY(Operate(addr, needed_num_pages, page_group, OperationType::MapGroup));
+        // Create a page group tohold the pages we allocate.
+        KPageGroup pg{m_kernel, m_block_info_manager};
+
+        R_TRY(m_system.Kernel().MemoryManager().AllocateAndOpen(
+            &pg, needed_num_pages,
+            KMemoryManager::EncodeOption(m_memory_pool, m_allocation_option)));
+
+        // Ensure that the page group is closed when we're done working with it.
+        SCOPE_EXIT({ pg.Close(); });
+
+        // Clear all pages.
+        for (const auto& it : pg) {
+            std::memset(m_system.DeviceMemory().GetPointer<void>(it.GetAddress()),
+                        m_heap_fill_value, it.GetSize());
+        }
+
+        R_TRY(Operate(addr, needed_num_pages, pg, OperationType::MapGroup));
    }

    // Update the blocks.
@@ -2795,19 +2768,28 @@ Result KPageTable::Operate(VAddr addr, size_t num_pages, const KPageGroup& page_
    ASSERT(num_pages > 0);
    ASSERT(num_pages == page_group.GetNumPages());

-    for (const auto& node : page_group.Nodes()) {
-        const size_t size{node.GetNumPages() * PageSize};
+    switch (operation) {
+    case OperationType::MapGroup: {
+        // We want to maintain a new reference to every page in the group.
+        KScopedPageGroup spg(page_group);

-        switch (operation) {
-        case OperationType::MapGroup:
+        for (const auto& node : page_group) {
+            const size_t size{node.GetNumPages() * PageSize};
+
+            // Map the pages.
            m_system.Memory().MapMemoryRegion(*m_page_table_impl, addr, size, node.GetAddress());
-            break;
-        default:
-            ASSERT(false);
-            break;
+
+            addr += size;
        }

-        addr += size;
+        // We succeeded! We want to persist the reference to the pages.
+        spg.CancelClose();
+
+        break;
+    }
+    default:
+        ASSERT(false);
+        break;
    }

    R_SUCCEED();
@@ -2822,13 +2804,29 @@ Result KPageTable::Operate(VAddr addr, size_t num_pages, KMemoryPermission perm,
    ASSERT(ContainsPages(addr, num_pages));

    switch (operation) {
-    case OperationType::Unmap:
+    case OperationType::Unmap: {
+        // Ensure that any pages we track close on exit.
+        KPageGroup pages_to_close{m_kernel, this->GetBlockInfoManager()};
+        SCOPE_EXIT({ pages_to_close.CloseAndReset(); });
+
+        this->AddRegionToPages(addr, num_pages, pages_to_close);
        m_system.Memory().UnmapRegion(*m_page_table_impl, addr, num_pages * PageSize);
        break;
+    }
+    case OperationType::MapFirst:
    case OperationType::Map: {
        ASSERT(map_addr);
        ASSERT(Common::IsAligned(map_addr, PageSize));
        m_system.Memory().MapMemoryRegion(*m_page_table_impl, addr, num_pages * PageSize, map_addr);
+
+        // Open references to pages, if we should.
+        if (IsHeapPhysicalAddress(m_kernel.MemoryLayout(), map_addr)) {
+            if (operation == OperationType::MapFirst) {
+                m_kernel.MemoryManager().OpenFirst(map_addr, num_pages);
+            } else {
+                m_kernel.MemoryManager().Open(map_addr, num_pages);
+            }
+        }
        break;
    }
    case OperationType::Separate: {
@@ -107,6 +107,10 @@ public:
        return *m_page_table_impl;
    }

+    KBlockInfoManager* GetBlockInfoManager() {
+        return m_block_info_manager;
+    }
+
    bool CanContain(VAddr addr, size_t size, KMemoryState state) const;

 protected:
@@ -261,10 +265,6 @@ private:
    void CleanupForIpcClientOnServerSetupFailure(PageLinkedList* page_list, VAddr address,
                                                 size_t size, KMemoryPermission prot_perm);

-    // HACK: These will be removed once we automatically manage page reference counts.
-    void HACK_OpenPages(PAddr phys_addr, size_t num_pages);
-    void HACK_ClosePages(VAddr virt_addr, size_t num_pages);
-
    mutable KLightLock m_general_lock;
    mutable KLightLock m_map_physical_memory_lock;

@@ -488,6 +488,7 @@ private:
    std::unique_ptr<Common::PageTable> m_page_table_impl;

    Core::System& m_system;
+    KernelCore& m_kernel;
 };

 } // namespace Kernel
@@ -285,6 +285,17 @@ void KProcess::UnregisterThread(KThread* thread) {
    thread_list.remove(thread);
 }

+u64 KProcess::GetFreeThreadCount() const {
+    if (resource_limit != nullptr) {
+        const auto current_value =
+            resource_limit->GetCurrentValue(LimitableResource::ThreadCountMax);
+        const auto limit_value = resource_limit->GetLimitValue(LimitableResource::ThreadCountMax);
+        return limit_value - current_value;
+    } else {
+        return 0;
+    }
+}
+
 Result KProcess::Reset() {
    // Lock the process and the scheduler.
    KScopedLightLock lk(state_lock);
@@ -304,6 +304,9 @@ public:
    /// from this process' thread list.
    void UnregisterThread(KThread* thread);

+    /// Retrieves the number of available threads for this process.
+    u64 GetFreeThreadCount() const;
+
    /// Clears the signaled state of the process if and only if it's signaled.
    ///
    /// @pre The process must not be already terminated. If this is called on a
@@ -5,9 +5,9 @@

 #include "common/common_types.h"
 #include "core/hle/kernel/global_scheduler_context.h"
+#include "core/hle/kernel/k_hardware_timer.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/time_manager.h"

 namespace Kernel {

@@ -22,7 +22,7 @@ public:
    ~KScopedSchedulerLockAndSleep() {
        // Register the sleep.
        if (timeout_tick > 0) {
-            kernel.TimeManager().ScheduleTimeEvent(thread, timeout_tick);
+            kernel.HardwareTimer().RegisterTask(thread, timeout_tick);
        }

        // Unlock the scheduler.
@@ -6,31 +6,29 @@
 #include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_scoped_resource_reservation.h"
 #include "core/hle/kernel/k_shared_memory.h"
+#include "core/hle/kernel/k_system_resource.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/svc_results.h"

 namespace Kernel {

 KSharedMemory::KSharedMemory(KernelCore& kernel_) : KAutoObjectWithSlabHeapAndContainer{kernel_} {}
-
-KSharedMemory::~KSharedMemory() {
-    kernel.GetSystemResourceLimit()->Release(LimitableResource::PhysicalMemoryMax, size);
-}
+KSharedMemory::~KSharedMemory() = default;

 Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,
-                                 KPageGroup&& page_list_, Svc::MemoryPermission owner_permission_,
-                                 Svc::MemoryPermission user_permission_, PAddr physical_address_,
-                                 std::size_t size_, std::string name_) {
+                                 Svc::MemoryPermission owner_permission_,
+                                 Svc::MemoryPermission user_permission_, std::size_t size_,
+                                 std::string name_) {
    // Set members.
    owner_process = owner_process_;
    device_memory = &device_memory_;
-    page_list = std::move(page_list_);
    owner_permission = owner_permission_;
    user_permission = user_permission_;
-    physical_address = physical_address_;
-    size = size_;
+    size = Common::AlignUp(size_, PageSize);
    name = std::move(name_);

+    const size_t num_pages = Common::DivideUp(size, PageSize);
+
    // Get the resource limit.
    KResourceLimit* reslimit = kernel.GetSystemResourceLimit();

@@ -39,6 +37,18 @@ Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* o
                                                  size_);
    R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);

+    // Allocate the memory.
+
+    //! HACK: Open continuous mapping from sysmodule pool.
+    auto option = KMemoryManager::EncodeOption(KMemoryManager::Pool::Secure,
+                                               KMemoryManager::Direction::FromBack);
+    physical_address = kernel.MemoryManager().AllocateAndOpenContinuous(num_pages, 1, option);
+    R_UNLESS(physical_address != 0, ResultOutOfMemory);
+
+    //! Insert the result into our page group.
+    page_group.emplace(kernel, &kernel.GetSystemSystemResource().GetBlockInfoManager());
+    page_group->AddBlock(physical_address, num_pages);
+
    // Commit our reservation.
    memory_reservation.Commit();

@@ -50,12 +60,18 @@ Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* o
    is_initialized = true;

    // Clear all pages in the memory.
-    std::memset(device_memory_.GetPointer<void>(physical_address_), 0, size_);
+    for (const auto& block : *page_group) {
+        std::memset(device_memory_.GetPointer<void>(block.GetAddress()), 0, block.GetSize());
+    }

    return ResultSuccess;
 }

 void KSharedMemory::Finalize() {
+    // Close and finalize the page group.
+    page_group->Close();
+    page_group->Finalize();
+
    // Release the memory reservation.
    resource_limit->Release(LimitableResource::PhysicalMemoryMax, size);
    resource_limit->Close();
@@ -65,32 +81,28 @@ void KSharedMemory::Finalize() {
 }

 Result KSharedMemory::Map(KProcess& target_process, VAddr address, std::size_t map_size,
-                          Svc::MemoryPermission permissions) {
-    const u64 page_count{(map_size + PageSize - 1) / PageSize};
+                          Svc::MemoryPermission map_perm) {
+    // Validate the size.
+    R_UNLESS(size == map_size, ResultInvalidSize);

-    if (page_list.GetNumPages() != page_count) {
-        UNIMPLEMENTED_MSG("Page count does not match");
-    }
-
-    const Svc::MemoryPermission expected =
+    // Validate the permission.
+    const Svc::MemoryPermission test_perm =
        &target_process == owner_process ? owner_permission : user_permission;
-
-    if (permissions != expected) {
-        UNIMPLEMENTED_MSG("Permission does not match");
+    if (test_perm == Svc::MemoryPermission::DontCare) {
+        ASSERT(map_perm == Svc::MemoryPermission::Read || map_perm == Svc::MemoryPermission::Write);
+    } else {
+        R_UNLESS(map_perm == test_perm, ResultInvalidNewMemoryPermission);
    }

-    return target_process.PageTable().MapPages(address, page_list, KMemoryState::Shared,
-                                               ConvertToKMemoryPermission(permissions));
+    return target_process.PageTable().MapPages(address, *page_group, KMemoryState::Shared,
+                                               ConvertToKMemoryPermission(map_perm));
 }

 Result KSharedMemory::Unmap(KProcess& target_process, VAddr address, std::size_t unmap_size) {
-    const u64 page_count{(unmap_size + PageSize - 1) / PageSize};
+    // Validate the size.
+    R_UNLESS(size == unmap_size, ResultInvalidSize);

-    if (page_list.GetNumPages() != page_count) {
-        UNIMPLEMENTED_MSG("Page count does not match");
-    }
-
-    return target_process.PageTable().UnmapPages(address, page_list, KMemoryState::Shared);
+    return target_process.PageTable().UnmapPages(address, *page_group, KMemoryState::Shared);
 }

 } // namespace Kernel
@@ -3,6 +3,7 @@

 #pragma once

+#include <optional>
 #include <string>

 #include "common/common_types.h"
@@ -26,9 +27,8 @@ public:
    ~KSharedMemory() override;

    Result Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,
-                      KPageGroup&& page_list_, Svc::MemoryPermission owner_permission_,
-                      Svc::MemoryPermission user_permission_, PAddr physical_address_,
-                      std::size_t size_, std::string name_);
+                      Svc::MemoryPermission owner_permission_,
+                      Svc::MemoryPermission user_permission_, std::size_t size_, std::string name_);

    /**
     * Maps a shared memory block to an address in the target process' address space
@@ -76,7 +76,7 @@ public:
 private:
    Core::DeviceMemory* device_memory{};
    KProcess* owner_process{};
-    KPageGroup page_list;
+    std::optional<KPageGroup> page_group{};
    Svc::MemoryPermission owner_permission{};
    Svc::MemoryPermission user_permission{};
    PAddr physical_address{};
@@ -22,6 +22,7 @@
 #include "core/hle/kernel/k_light_lock.h"
 #include "core/hle/kernel/k_spin_lock.h"
 #include "core/hle/kernel/k_synchronization_object.h"
+#include "core/hle/kernel/k_timer_task.h"
 #include "core/hle/kernel/k_worker_task.h"
 #include "core/hle/kernel/slab_helpers.h"
 #include "core/hle/kernel/svc_common.h"
@@ -112,7 +113,8 @@ void SetCurrentThread(KernelCore& kernel, KThread* thread);
 [[nodiscard]] s32 GetCurrentCoreId(KernelCore& kernel);

 class KThread final : public KAutoObjectWithSlabHeapAndContainer<KThread, KWorkerTask>,
-                      public boost::intrusive::list_base_hook<> {
+                      public boost::intrusive::list_base_hook<>,
+                      public KTimerTask {
    KERNEL_AUTOOBJECT_TRAITS(KThread, KSynchronizationObject);

 private:
@@ -840,4 +842,8 @@ private:
    KernelCore& kernel;
 };

+inline void KTimerTask::OnTimer() {
+    static_cast<KThread*>(this)->OnTimer();
+}
+
 } // namespace Kernel
--- a/Show More
+++ b/Show More