BSD macro too

Fix license headers
[video_core/buffer_cache] fix PAGE_SHIFT macro clash on FBSD
2026-08-31 18:46:08 +00:00 · 2026-08-31 18:03:33 +00:00 · 2026-08-31 03:58:49 +00:00 · 2026-08-31 03:43:50 +00:00 · 2026-08-31 04:22:15 +02:00 · 2026-08-31 02:58:09 +02:00
133 changed files with 496 additions and 554 deletions
@@ -1,26 +0,0 @@
-From b3622608433c183ba868a1dc8dd9cf285eb3b916 Mon Sep 17 00:00:00 2001
-From: Dario Petrillo <dario.pk1@gmail.com>
-Date: Thu, 27 Nov 2025 23:12:38 +0100
-Subject: [PATCH] avoid extra memset when clearing an empty table
-
---
- include/ankerl/unordered_dense.h | 6 ++++--
- 1 file changed, 4 insertions(+), 2 deletions(-)
-
-diff --git a/include/ankerl/unordered_dense.h b/include/ankerl/unordered_dense.h
-index 0835342..4938212 100644
--- a/include/ankerl/unordered_dense.h
-+++ b/include/ankerl/unordered_dense.h
-@@ -1490,8 +1490,10 @@ class table : public std::conditional_t<is_map_v<T>, base_table_type_map<T>, bas
-     // modifiers //////////////////////////////////////////////////////////////
- 
-     void clear() {
-        m_values.clear();
-        clear_buckets();
-+        if (!empty()) {
-+            m_values.clear();
-+            clear_buckets();
-+        }
-     }
- 
-     auto insert(value_type const& value) -> std::pair<iterator, bool> {
@@ -540,7 +540,6 @@ add_subdirectory(externals)
 # pass targets from externals
 # TODO(crueter): CPMUtil Propagate func?
 find_package(enet)
-find_package(unordered_dense REQUIRED)

 if (ARCHITECTURE_x86 OR ARCHITECTURE_x86_64)
    find_package(xbyak)
@@ -301,17 +301,6 @@
        "repo": "eden-emu/tzdb_to_nx",
        "version": "230326"
    },
-    "unordered-dense": {
-        "bundled": true,
-        "find_args": "CONFIG",
-        "hash": "d2106f6640f6bfb81755e4b8bfb64982e46ec4a507cacdb38f940123212ccf35a20b43c70c6f01d7bfb8c246d1a16f7845d8052971949cea9def1475e3fa02c8",
-        "package": "unordered_dense",
-        "patches": [
-            "0001-avoid-memset-when-clearing-an-empty-table.patch"
-        ],
-        "repo": "martinus/unordered_dense",
-        "version": "7b55cab841"
-    },
    "vulkan-headers": {
        "hash": "d2846ea228415772645eea4b52a9efd33e6a563043dd3de059e798be6391a8f0ca089f455ae420ff22574939ed0f48ed7c6ff3d5a9987d5231dbf3b3f89b484b",
        "min_version": "1.4.317",
@@ -80,7 +80,6 @@ Certain other dependencies will be fetched by CPM regardless. System packages *c
 * [httplib](https://github.com/yhirose/cpp-httplib) - if `ENABLE_UPDATE_CHECKER` or `ENABLE_WEB_SERVICE` are on
  * This package is known to be broken on the AUR.
 * [cpp-jwt](https://github.com/arun11299/cpp-jwt) 1.4+ - if `ENABLE_WEB_SERVICE` is on
-* [unordered-dense](https://github.com/martinus/unordered_dense)

 On amd64:

@@ -119,7 +118,7 @@ Now, install all deps:
 sudo emerge -a \
    app-arch/lz4 app-arch/zstd app-arch/unzip \
    dev-libs/libfmt dev-libs/libusb dev-libs/mcl dev-libs/sirit \
-    dev-libs/unordered_dense dev-libs/boost dev-libs/openssl dev-libs/discord-rpc \
+    dev-libs/boost dev-libs/openssl dev-libs/discord-rpc \
    dev-util/spirv-tools dev-util/spirv-headers dev-util/vulkan-headers \
    dev-util/vulkan-utility-libraries dev-util/glslang \
    media-gfx/renderdoc media-libs/libva media-libs/opus media-video/ffmpeg \
@@ -260,7 +259,7 @@ brew install molten-vk
 <details>
 <summary>FreeBSD</summary>

-As root run: `pkg install devel/cmake sdl3 devel/boost-libs devel/catch2 devel/libfmt devel/nlohmann-json devel/ninja devel/nasm devel/autoconf devel/pkgconf devel/qt6-base devel/qt6-charts devel/simpleini net/enet multimedia/ffnvcodec-headers multimedia/ffmpeg audio/opus archivers/liblz4 lang/gcc12 graphics/glslang graphics/vulkan-utility-libraries graphics/spirv-tools www/cpp-httplib devel/unordered-dense vulkan-headers quazip-qt6`
+As root run: `pkg install devel/cmake sdl3 devel/boost-libs devel/catch2 devel/libfmt devel/nlohmann-json devel/ninja devel/nasm devel/autoconf devel/pkgconf devel/qt6-base devel/qt6-charts devel/simpleini net/enet multimedia/ffnvcodec-headers multimedia/ffmpeg audio/opus archivers/liblz4 lang/gcc12 graphics/glslang graphics/vulkan-utility-libraries graphics/spirv-tools www/cpp-httplib vulkan-headers quazip-qt6`

 If using FreeBSD 12 or prior, use `devel/pkg-config` instead.

@@ -294,7 +293,7 @@ pkg_add cmake nasm git boost unzip--iconv autoconf-2.72p0 bash ffmpeg glslang gm
 <summary>DragonFlyBSD</summary>

 ```sh
-pkg install gcc14 git cmake unzip nasm autoconf bash pkgconf ffmpeg glslang gmake jq nlohmann-json enet spirv-tools sdl3 vulkan-utility-libraries vulkan-headers catch2 libfmt openssl liblz4 boost-libs cpp-httplib qt6-base qt6-charts quazip-qt6 unordered-dense libva-vdpau-driver libva-utils libva-intel-driver
+pkg install gcc14 git cmake unzip nasm autoconf bash pkgconf ffmpeg glslang gmake jq nlohmann-json enet spirv-tools sdl3 vulkan-utility-libraries vulkan-headers catch2 libfmt openssl liblz4 boost-libs cpp-httplib qt6-base qt6-charts quazip-qt6 libva-vdpau-driver libva-utils libva-intel-driver
 ```

 [Caveats](./Caveats.md#dragonflybsd).
@@ -328,7 +327,7 @@ sudo pkgin install git cmake autoconf build-essential libusb-1 nasm gcc13

 ```sh
 BASE="git make autoconf libtool automake-wrapper jq patch"
-MINGW="qt6-base qt6-charts qt6-tools qt6-translations qt6-svg cmake toolchain clang python-pip openssl vulkan-memory-allocator vulkan-devel glslang boost fmt lz4 nlohmann-json zlib zstd enet opus libusb unordered_dense openssl SDL3"
+MINGW="qt6-base qt6-charts qt6-tools qt6-translations qt6-svg cmake toolchain clang python-pip openssl vulkan-memory-allocator vulkan-devel glslang boost fmt lz4 nlohmann-json zlib zstd enet opus libusb openssl SDL3"
 # Either x86_64 or clang-aarch64 (Windows on ARM)
 packages="$BASE"
 for pkg in $MINGW; do
@@ -308,32 +308,6 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```

-### unordered_dense
-
-```
-MIT License
-
-Copyright (c) 2022 Martin Leitner-Ankerl
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-```
-
 ### xbyak

 ```
@@ -58,9 +58,6 @@ if (WIN32 AND NOT TARGET LLVM::Demangle)
    add_library(LLVM::Demangle ALIAS demangle)
 endif()

-# unordered_dense
-AddJsonPackage(unordered-dense)
-
 # httplib
 if (IOS)
    set(HTTPLIB_USE_BROTLI_IF_AVAILABLE OFF)
@@ -11,6 +11,7 @@ import org.yuzu.yuzu_emu.utils.NativeConfig
 enum class StringSetting(override val key: String) : AbstractStringSetting {
    DRIVER_PATH("driver_path"),
    DEVICE_NAME("device_name"),
+    LOG_FILTER("log_filter"),
    PROGRAM_ARGS("program_args"),

    WEB_TOKEN("eden_token"),
@@ -1033,6 +1033,13 @@ abstract class SettingsItem(
                    descriptionId = R.string.use_auto_stub_description
                )
            )
+            put(
+                StringInputSetting(
+                    StringSetting.LOG_FILTER,
+                    titleId = R.string.log_filter,
+                    descriptionId = R.string.log_filter_description
+                )
+            )
            put(
                SpinBoxSetting(
                    UShortSetting.DEBUG_KNOBS,
@@ -1323,6 +1323,7 @@ class SettingsFragmentPresenter(
                add(HeaderSetting(R.string.log))

                add(BooleanSetting.DEBUG_FLUSH_BY_LINE.key)
+                add(StringSetting.LOG_FILTER.key)
            }

            add(HeaderSetting(R.string.general))
@@ -20,7 +20,7 @@ struct RomMetadata {
    std::vector<u8> icon;
    bool isHomebrew;
 };
-static ankerl::unordered_dense::map<std::string, RomMetadata> m_rom_metadata_cache;
+static ::Common::unordered_map<std::string, RomMetadata> m_rom_metadata_cache;

 static RomMetadata CacheRomMetadata(const std::string& path) {
    auto& instance = EmulationSession::GetInstance();
@@ -21,7 +21,7 @@
 #include "input_common/drivers/virtual_gamepad.h"
 #include "native.h"

-ankerl::unordered_dense::map<std::string, std::unique_ptr<AndroidConfig>> map_profiles;
+::Common::unordered_map<std::string, std::unique_ptr<AndroidConfig>> map_profiles;

 bool IsHandheldOnly() {
    const auto npad_style_set =
@@ -636,6 +636,8 @@
    <string name="log">Logging</string>
    <string name="flush_by_line">Flush debug logs by line</string>
    <string name="flush_by_line_description">Flushes debugging logs on each line written, making debugging easier in cases of crashing or freezing.</string>
+    <string name="log_filter">Log filter</string>
+    <string name="log_filter_description">Controls Eden\'s log categories. Example: *:Info Service.LM:Debug</string>

    <!-- GPU Logging strings -->
    <string name="gpu_logging_header">GPU Logging</string>
@@ -147,7 +147,8 @@ add_library(
    cpu_features.cpp
    cpu_features.h
    httplib.h
-    net/net.h net/net.cpp)
+    net/net.h net/net.cpp
+    container/unordered_map.h container/unordered_set.h)

 if(WIN32)
    target_sources(common PRIVATE windows/timer_resolution.cpp
@@ -241,7 +242,7 @@ if (lz4_ADDED)
    target_include_directories(common PRIVATE ${lz4_SOURCE_DIR}/lib)
 endif()

-target_link_libraries(common PUBLIC fmt::fmt stb::headers Threads::Threads unordered_dense::unordered_dense)
+target_link_libraries(common PUBLIC fmt::fmt stb::headers Threads::Threads)
 target_link_libraries(common PRIVATE lz4::lz4 zstd::zstd)

 # Please refer to src/common/demangle.cpp
@@ -0,0 +1,16 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "common/container_hash.h"
+
+#include <boost/unordered/unordered_flat_map.hpp>
+
+namespace Common {
+
+template <class Key, class T, class Hash = std::hash<Key>, class Pred = std::equal_to<Key>,
+          class Allocator = std::allocator<std::pair<const Key, T>>>
+using unordered_map = boost::unordered::unordered_flat_map<Key, T, Hash, Pred, Allocator>;
+
+}
@@ -0,0 +1,16 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "common/container_hash.h"
+
+#include <boost/unordered/unordered_flat_set.hpp>
+
+namespace Common {
+
+template <class Key, class Hash = std::hash<Key>, class Pred = std::equal_to<Key>,
+          class Allocator = std::allocator<Key>>
+using unordered_set = boost::unordered::unordered_flat_set<Key, Hash, Pred, Allocator>;
+
+}
@@ -10,8 +10,11 @@
 #include <array>
 #include <climits>
 #include <cstdint>
+#include <functional>
 #include <limits>
+#include <tuple>
 #include <type_traits>
+#include <utility>
 #include <vector>

 namespace Common {
@@ -69,10 +72,17 @@ struct HashCombineImpl<64> {
 } // namespace detail

 template <typename T>
+    requires std::is_unsigned_v<T>
 inline void HashCombine(std::size_t& seed, const T& v) {
    seed = detail::HashCombineImpl<sizeof(std::size_t) * CHAR_BIT>::fn(seed, detail::HashValue(v));
 }

+template <typename T>
+    requires (!std::is_unsigned_v<T>)
+inline void HashCombine(std::size_t& seed, const T& v) {
+    seed = detail::HashCombineImpl<sizeof(std::size_t) * CHAR_BIT>::fn(seed, std::hash<T>{}(v));
+}
+
 template <typename It>
 inline std::size_t HashRange(It first, It last) {
    std::size_t seed = 0;
@@ -95,3 +105,26 @@ std::size_t HashValue(const std::vector<T, Allocator>& v) {
 }

 } // namespace Common
+
+namespace std {
+
+template <typename... Args>
+struct hash<std::tuple<Args...>> {
+    std::size_t operator()(const std::tuple<Args...>& t) const noexcept {
+        std::size_t seed = 0;
+        std::apply([&seed](const Args&... args) { (Common::HashCombine(seed, args), ...); }, t);
+        return seed;
+    }
+};
+
+template <class A, class B>
+struct hash<std::pair<A, B>> {
+    std::size_t operator()(const std::pair<A, B>& p) const noexcept {
+        std::size_t seed = 0;
+        Common::HashCombine(seed, p.first);
+        Common::HashCombine(seed, p.second);
+        return seed;
+    }
+};
+
+} // namespace std
@@ -7,7 +7,7 @@
 #include <algorithm>
 #include <iostream>
 #include <sstream>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include "common/assert.h"
 #include "common/fs/fs.h"
@@ -196,8 +196,8 @@ private:
        SetLegacyPathImpl(legacy_path, new_path);
    }

-    ankerl::unordered_dense::map<EdenPath, fs::path> eden_paths;
-    ankerl::unordered_dense::map<EmuPath, fs::path> legacy_paths;
+    ::Common::unordered_map<EdenPath, fs::path> eden_paths;
+    ::Common::unordered_map<EmuPath, fs::path> legacy_paths;
 };

 bool ValidatePath(const fs::path& path) {
@@ -7,7 +7,7 @@
 #ifdef _WIN32

 #include <iterator>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <boost/icl/separate_interval_set.hpp>
 #include <windows.h>
 #include "common/dynamic_library.h"
@@ -391,7 +391,7 @@ private:

    std::mutex placeholder_mutex;                                 ///< Mutex for placeholders
    boost::icl::separate_interval_set<size_t> placeholders;       ///< Mapped placeholders
-    ankerl::unordered_dense::map<size_t, size_t> placeholder_host_pointers; ///< Placeholder backing offset
+    ::Common::unordered_map<size_t, size_t> placeholder_host_pointers; ///< Placeholder backing offset
 };

 #elif defined(__OPENORBIS__) || defined(__managarm__)
@@ -9,7 +9,7 @@
 #include <functional>
 #include <memory>
 #include <string>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <utility>
 #include <vector>
 #include "common/logging.h"
@@ -412,7 +412,7 @@ public:
 namespace Impl {

 template <typename InputDeviceType>
-using FactoryListType = ankerl::unordered_dense::map<std::string, std::shared_ptr<Factory<InputDeviceType>>>;
+using FactoryListType = ::Common::unordered_map<std::string, std::shared_ptr<Factory<InputDeviceType>>>;

 template <typename InputDeviceType>
 struct FactoryList {
@@ -8,14 +8,14 @@

 #include <initializer_list>
 #include <string>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 namespace Common {

 /// A string-based key-value container supporting serializing to and deserializing from a string
 class ParamPackage {
 public:
-    using DataType = ankerl::unordered_dense::map<std::string, std::string>;
+    using DataType = ::Common::unordered_map<std::string, std::string>;

    ParamPackage() = default;
    explicit ParamPackage(const std::string& serialized);
@@ -22,10 +22,11 @@
 #endif

 // You must ensure this matches with src/common/x64/xbyak.h on root dir
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
+#include "common/container/unordered_set.h"
 #include <boost/unordered_map.hpp>
-#define XBYAK_STD_UNORDERED_SET ankerl::unordered_dense::set
-#define XBYAK_STD_UNORDERED_MAP ankerl::unordered_dense::map
+#define XBYAK_STD_UNORDERED_SET ::Common::unordered_set
+#define XBYAK_STD_UNORDERED_MAP ::Common::unordered_map
 #define XBYAK_STD_UNORDERED_MULTIMAP boost::unordered_multimap
 #include <xbyak/xbyak.h>
 #include <xbyak/xbyak_util.h>
@@ -8,7 +8,7 @@

 #include <atomic>
 #include <memory>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include <dynarmic/interface/A64/a64.h>
 #include <dynarmic/interface/code_page.h>
@@ -4,7 +4,7 @@
 #pragma once

 #include <span>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <vector>
 #include <oaknut/code_block.hpp>
 #include <oaknut/oaknut.hpp>
@@ -46,7 +46,7 @@ enum class PatchMode : u32 {

 using ModuleTextAddress = u64;
 using PatchTextAddress = u64;
-using EntryTrampolines = ankerl::unordered_dense::map<ModuleTextAddress, PatchTextAddress>;
+using EntryTrampolines = ::Common::unordered_map<ModuleTextAddress, PatchTextAddress>;

 class Patcher {
 public:
@@ -8,7 +8,7 @@
 #include <utility>
 #include <span>
 #include <cctype>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include "common/hex_util.h"
 #include "common/logging.h"
@@ -104,7 +104,7 @@ struct IPSwitchRecord {
    size_t count;
 };
 struct IPSwitchCompiler::IPSwitchPatch {
-    ankerl::unordered_dense::map<u32, IPSwitchRecord> records;
+    ::Common::unordered_map<u32, IPSwitchRecord> records;
    bool enabled;
 };

@@ -566,7 +566,7 @@ VirtualFile RegisteredCache::GetFileAtID(NcaID id) const {
    return file;
 }

-static std::optional<NcaID> CheckMapForContentRecord(const ankerl::unordered_dense::map<u64, CNMT>& map, u64 title_id, ContentRecordType type) {
+static std::optional<NcaID> CheckMapForContentRecord(const ::Common::unordered_map<u64, CNMT>& map, u64 title_id, ContentRecordType type) {
    auto cmnt_iter = map.find(title_id);
    u8 id_offset = 0;

@@ -12,7 +12,7 @@
 #include <optional>
 #include <string>
 #include <vector>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <boost/container/flat_map.hpp>
 #include "common/common_types.h"
 #include "core/crypto/key_manager.h"
@@ -209,11 +209,11 @@ private:
    ContentProviderParsingFunction parser;

    // maps tid -> NcaID of meta
-    ankerl::unordered_dense::map<u64, NcaID> meta_id;
+    ::Common::unordered_map<u64, NcaID> meta_id;
    // maps tid -> meta
-    ankerl::unordered_dense::map<u64, CNMT> meta;
+    ::Common::unordered_map<u64, CNMT> meta;
    // maps tid -> meta for CNMT in yuzu_meta
-    ankerl::unordered_dense::map<u64, CNMT> yuzu_meta;
+    ::Common::unordered_map<u64, CNMT> yuzu_meta;
 };

 enum class ContentProviderUnionSlot {
@@ -313,8 +313,8 @@ private:
    void ProcessXCI(const VirtualFile& file);

    std::vector<VirtualDir> load_dirs;
-    ankerl::unordered_dense::map<std::tuple<u64, ContentRecordType, TitleType>, VirtualFile> entries;
-    ankerl::unordered_dense::map<u64, u32> versions;
+    ::Common::unordered_map<std::tuple<u64, ContentRecordType, TitleType>, VirtualFile> entries;
+    ::Common::unordered_map<u64, u32> versions;
    std::vector<ExternalUpdateEntry> multi_version_entries;
 };

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

 #include <algorithm>
 #include <set>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_set.h"
 #include <utility>
 #include "core/file_sys/vfs/vfs_layered.h"

@@ -63,7 +63,7 @@ std::string LayeredVfsDirectory::GetFullPath() const {

 std::vector<VirtualFile> LayeredVfsDirectory::GetFiles() const {
    std::vector<VirtualFile> out;
-    ankerl::unordered_dense::set<std::string> out_names;
+    ::Common::unordered_set<std::string> out_names;

    for (const auto& layer : dirs) {
        for (auto& file : layer->GetFiles()) {
@@ -79,7 +79,7 @@ std::vector<VirtualFile> LayeredVfsDirectory::GetFiles() const {

 std::vector<VirtualDir> LayeredVfsDirectory::GetSubdirectories() const {
    std::vector<VirtualDir> out;
-    ankerl::unordered_dense::set<std::string> out_names;
+    ::Common::unordered_set<std::string> out_names;

    for (const auto& layer : dirs) {
        for (const auto& sd : layer->GetSubdirectories()) {
@@ -78,7 +78,7 @@ private:
    std::array<DebugWatchpoint, Core::Hardware::NUM_WATCHPOINTS> m_watchpoints{};
    std::map<KProcessAddress, u64> m_debug_page_refcounts{};
 #ifdef HAS_NCE
-    ankerl::unordered_dense::map<u64, u64> m_post_handlers{};
+    ::Common::unordered_map<u64, u64> m_post_handlers{};
 #endif
    std::unique_ptr<Core::ExclusiveMonitor> m_exclusive_monitor;
    Core::Memory::Memory m_memory;
@@ -494,7 +494,7 @@ public:
    static void Switch(KernelCore& kernel, KProcess* cur_process, KProcess* next_process);

 #ifdef HAS_NCE
-    ankerl::unordered_dense::map<u64, u64>& GetPostHandlers() noexcept {
+    ::Common::unordered_map<u64, u64>& GetPostHandlers() noexcept {
        return m_post_handlers;
    }
 #endif
@@ -10,7 +10,8 @@
 #include <functional>
 #include <memory>
 #include <thread>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
+#include "common/container/unordered_set.h"
 #include <utility>

 #include "common/assert.h"
@@ -792,8 +793,8 @@ struct KernelCore::Impl {

    std::optional<KObjectNameGlobalData> object_name_global_data;

-    ankerl::unordered_dense::set<KAutoObject*> registered_objects;
-    ankerl::unordered_dense::set<KAutoObject*> registered_in_use_objects;
+    ::Common::unordered_set<KAutoObject*> registered_objects;
+    ::Common::unordered_set<KAutoObject*> registered_in_use_objects;

    std::mutex server_lock;
    std::vector<std::unique_ptr<Service::ServerManager>> server_managers;
@@ -11,7 +11,7 @@
 #include <list>
 #include <memory>
 #include <string>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <vector>

 #include "common/polyfill_thread.h"
@@ -7,7 +7,7 @@
 #pragma once

 #include <array>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <vector>

 #include "common/common_funcs.h"
@@ -176,6 +176,6 @@ struct WebCommonReturnValue {
 };
 static_assert(sizeof(WebCommonReturnValue) == 0x1010, "WebCommonReturnValue has incorrect size.");

-using WebArgInputTLVMap = ankerl::unordered_dense::map<WebArgInputTLVType, std::vector<u8>>;
+using WebArgInputTLVMap = ::Common::unordered_map<WebArgInputTLVType, std::vector<u8>>;

 } // namespace Service::AM::Frontend
@@ -40,8 +40,8 @@ std::vector<u8> default_logo_small;
 std::vector<u8> default_logo_large;
 bool default_logos_loaded = false;

-ankerl::unordered_dense::map<std::string, std::vector<u8>> news_images_small;
-ankerl::unordered_dense::map<std::string, std::vector<u8>> news_images_large;
+::Common::unordered_map<std::string, std::vector<u8>> news_images_small;
+::Common::unordered_map<std::string, std::vector<u8>> news_images_large;
 std::mutex images_mutex;


@@ -12,7 +12,7 @@
 #include <optional>
 #include <span>
 #include <string>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <vector>

 #include "common/common_types.h"
@@ -93,7 +93,7 @@ private:
    static s64 Now();

    mutable std::mutex mtx;
-    ankerl::unordered_dense::map<std::string, StoredNews> items;
+    ::Common::unordered_map<std::string, StoredNews> items;
    size_t open_counter{};
 };

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

 #pragma once

-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include "common/fs/fs.h"
 #include "core/hle/result.h"
@@ -88,7 +88,7 @@ private:
    AlbumFileDateTime ConvertToAlbumDateTime(u64 posix_time) const;

    bool is_mounted{};
-    ankerl::unordered_dense::map<AlbumFileId, std::filesystem::path> album_files;
+    ::Common::unordered_map<AlbumFileId, std::filesystem::path> album_files;

    Core::System& system;
 };
@@ -15,7 +15,7 @@
 #include <random>
 #include <span>
 #include <thread>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include "common/logging.h"
 #include "common/socket_types.h"
@@ -119,7 +119,7 @@ protected:
    std::array<LanStation, StationCountMax> stations;
    std::array<NodeLatestUpdate, NodeCountMax> node_changes{};
    std::array<u8, NodeCountMax> node_last_states{};
-    ankerl::unordered_dense::map<MacAddress, NetworkInfo, MACAddressHash> scan_results{};
+    ::Common::unordered_map<MacAddress, NetworkInfo, MACAddressHash> scan_results{};
    NodeInfo node_info{};
    NetworkInfo network_info{};
    State state{State::None};
@@ -7,7 +7,7 @@
 #include <string>

 #include <optional>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <boost/container_hash/hash.hpp>
 #include "common/logging.h"
 #include "core/core.h"
@@ -331,7 +331,7 @@ private:
    };
    static_assert(sizeof(LogPacketHeader) == 0x18, "LogPacketHeader is an invalid size");

-    ankerl::unordered_dense::map<LogPacketHeaderEntry, std::vector<u8>> entries{};
+    ::Common::unordered_map<LogPacketHeaderEntry, std::vector<u8>> entries{};
    LogDestination destination{LogDestination::All};
 };

@@ -23,7 +23,7 @@
 #include <mutex>
 #include <optional>
 #include <thread>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <common/settings.h>

 #ifdef _WIN32
@@ -9,7 +9,7 @@

 #include <deque>
 #include <memory>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include "core/device_memory_manager.h"
 #include "core/hle/service/nvdrv/nvdata.h"
@@ -12,7 +12,7 @@
 #include <memory>
 #include <mutex>
 #include <optional>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <assert.h>

 #include "common/bit_field.h"
@@ -161,7 +161,7 @@ private:
    std::list<std::shared_ptr<Handle>> unmap_queue{};
    std::mutex unmap_queue_lock{}; //!< Protects access to `unmap_queue`

-    ankerl::unordered_dense::map<Handle::Id, std::shared_ptr<Handle>>
+    ::Common::unordered_map<Handle::Id, std::shared_ptr<Handle>>
        handles{};           //!< Main owning map of handles
    std::mutex handles_lock; //!< Protects access to `handles`

@@ -13,7 +13,7 @@
 #include <memory>
 #include <mutex>
 #include <optional>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_set.h"
 #include <vector>

 #include "common/address_space.h"
@@ -113,7 +113,7 @@ private:
    };
    static_assert(sizeof(IoctlRemapEntry) == 20, "IoctlRemapEntry is incorrect size");

-    ankerl::unordered_dense::set<s64_le> map_buffer_offsets{};
+    ::Common::unordered_set<s64_le> map_buffer_offsets{};

    struct IoctlMapBufferEx {
        MappingFlags flags{}; // bit0: fixed_offset, bit2: cacheable
@@ -217,7 +217,7 @@ private:
    NvCore::SyncpointManager& syncpoint_manager;
    NvCore::NvMap& nvmap;
    std::shared_ptr<Tegra::Control::ChannelState> channel_state;
-    ankerl::unordered_dense::map<DeviceFD, NvCore::SessionId> sessions;
+    ::Common::unordered_map<DeviceFD, NvCore::SessionId> sessions;
    u32 channel_syncpoint;
    std::mutex channel_mutex;

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

 #include <deque>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <vector>

 #include "common/common_types.h"
@@ -138,7 +138,7 @@ protected:
    NvCore::NvMap& nvmap;
    NvCore::ChannelType channel_type;
    std::array<u32, MaxSyncPoints> device_syncpoints{};
-    ankerl::unordered_dense::map<DeviceFD, NvCore::SessionId> sessions;
+    ::Common::unordered_map<DeviceFD, NvCore::SessionId> sessions;
 };
 }; // namespace Devices
 } // namespace Service::Nvidia
@@ -7,7 +7,7 @@
 #pragma once

 #include <memory>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <vector>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -118,7 +118,7 @@ private:

    NvCore::Container& container;
    NvCore::NvMap& file;
-    ankerl::unordered_dense::map<DeviceFD, NvCore::SessionId> sessions;
+    ::Common::unordered_map<DeviceFD, NvCore::SessionId> sessions;
 };

 } // namespace Service::Nvidia::Devices
@@ -12,7 +12,7 @@
 #include <memory>
 #include <span>
 #include <string>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include "common/common_types.h"
 #include "core/hle/service/kernel_helpers.h"
@@ -103,7 +103,7 @@ private:
    /// Id to use for the next open file descriptor.
    DeviceFD next_fd = 1;

-    using FilesContainerType = ankerl::unordered_dense::map<DeviceFD, std::shared_ptr<Devices::nvdevice>>;
+    using FilesContainerType = ::Common::unordered_map<DeviceFD, std::shared_ptr<Devices::nvdevice>>;
    /// Mapping of file descriptors to the devices they reference.
    FilesContainerType open_files;

@@ -111,7 +111,7 @@ private:

    EventInterface events_interface;

-    ankerl::unordered_dense::map<std::string, std::function<FilesContainerType::iterator(DeviceFD)>> builders;
+    ::Common::unordered_map<std::string, std::function<FilesContainerType::iterator(DeviceFD)>> builders;
 };

 void LoopProcess(Core::System& system);
@@ -8,7 +8,7 @@

 #include <memory>
 #include <mutex>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include "common/common_types.h"
 #include "core/hle/service/nvnflinger/binder.h"
@@ -39,8 +39,8 @@ private:

    mutable std::mutex lock;
    s32 last_id = 0;
-    ankerl::unordered_dense::map<s32, std::shared_ptr<android::IBinder>> binders;
-    ankerl::unordered_dense::map<s32, RefCounts> refcounts;
+    ::Common::unordered_map<s32, std::shared_ptr<android::IBinder>> binders;
+    ::Common::unordered_map<s32, RefCounts> refcounts;
 };

 } // namespace Service::Nvnflinger
@@ -6,7 +6,7 @@

 #pragma once

-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include "common/uuid.h"
 #include "core/hle/service/cmif_types.h"
@@ -56,10 +56,10 @@ private:
        }
    };

-    ankerl::unordered_dense::map<AppKey, bool, AppKeyHash> app_auto_transfer_{};
-    ankerl::unordered_dense::map<Common::UUID, bool> global_auto_upload_{};
-    ankerl::unordered_dense::map<Common::UUID, bool> global_auto_download_{};
-    ankerl::unordered_dense::map<AppKey, u8, AppKeyHash> autonomy_task_status_{};
+    ::Common::unordered_map<AppKey, bool, AppKeyHash> app_auto_transfer_{};
+    ::Common::unordered_map<Common::UUID, bool> global_auto_upload_{};
+    ::Common::unordered_map<Common::UUID, bool> global_auto_download_{};
+    ::Common::unordered_map<AppKey, u8, AppKeyHash> autonomy_task_status_{};
 };

 } // namespace Service::OLSC
@@ -8,7 +8,7 @@

 #include <cstddef>
 #include <mutex>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include "common/common_types.h"
 #include "core/hle/service/hle_ipc.h"

@@ -99,8 +99,8 @@ private:
    void ReportUnimplementedFunction(HLERequestContext& ctx, const FunctionInfoBase* info);

 protected:
-    ankerl::unordered_dense::map<u32, FunctionInfoBase> handlers;
-    ankerl::unordered_dense::map<u32, FunctionInfoBase> handlers_tipc;
+    ::Common::unordered_map<u32, FunctionInfoBase> handlers;
+    ::Common::unordered_map<u32, FunctionInfoBase> handlers_tipc;
    /// Used to gain exclusive access to the service members, e.g. from CoreTiming thread.
    std::mutex lock_service;
    /// System context that the service operates under.
@@ -10,7 +10,7 @@
 #include <memory>
 #include <mutex>
 #include <string>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <concepts>

 #include "core/hle/kernel/k_port.h"
@@ -100,8 +100,8 @@ private:

    /// Map of registered services, retrieved using GetServicePort.
    mutable std::mutex lock;
-    ankerl::unordered_dense::map<std::string, SessionRequestHandlerFactory> registered_services;
-    ankerl::unordered_dense::map<std::string, Kernel::KClientPort*> service_ports;
+    ::Common::unordered_map<std::string, SessionRequestHandlerFactory> registered_services;
+    ::Common::unordered_map<std::string, Kernel::KClientPort*> service_ports;

    /// Kernel context
    Kernel::KernelCore& kernel;
@@ -54,11 +54,11 @@ void PutValue(std::span<u8> buffer, const T& t) {

 } // Anonymous namespace

-void BSD::PollWork::Execute(BSD* bsd) {
+void BSD_USA::PollWork::Execute(BSD_USA* bsd) {
    std::tie(ret, bsd_errno) = bsd->PollImpl(write_buffer, read_buffer, nfds, timeout);
 }

-void BSD::PollWork::Response(HLERequestContext& ctx) {
+void BSD_USA::PollWork::Response(HLERequestContext& ctx) {
    if (write_buffer.size() > 0) {
        ctx.WriteBuffer(write_buffer);
    }
@@ -69,11 +69,11 @@ void BSD::PollWork::Response(HLERequestContext& ctx) {
    rb.PushEnum(bsd_errno);
 }

-void BSD::AcceptWork::Execute(BSD* bsd) {
+void BSD_USA::AcceptWork::Execute(BSD_USA* bsd) {
    std::tie(ret, bsd_errno) = bsd->AcceptImpl(fd, write_buffer);
 }

-void BSD::AcceptWork::Response(HLERequestContext& ctx) {
+void BSD_USA::AcceptWork::Response(HLERequestContext& ctx) {
    if (write_buffer.size() > 0) {
        ctx.WriteBuffer(write_buffer);
    }
@@ -85,22 +85,22 @@ void BSD::AcceptWork::Response(HLERequestContext& ctx) {
    rb.Push<u32>(static_cast<u32>(write_buffer.size()));
 }

-void BSD::ConnectWork::Execute(BSD* bsd) {
+void BSD_USA::ConnectWork::Execute(BSD_USA* bsd) {
    bsd_errno = bsd->ConnectImpl(fd, addr);
 }

-void BSD::ConnectWork::Response(HLERequestContext& ctx) {
+void BSD_USA::ConnectWork::Response(HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(ResultSuccess);
    rb.Push<s32>(bsd_errno == Errno::SUCCESS ? 0 : -1);
    rb.PushEnum(bsd_errno);
 }

-void BSD::RecvWork::Execute(BSD* bsd) {
+void BSD_USA::RecvWork::Execute(BSD_USA* bsd) {
    std::tie(ret, bsd_errno) = bsd->RecvImpl(fd, flags, message);
 }

-void BSD::RecvWork::Response(HLERequestContext& ctx) {
+void BSD_USA::RecvWork::Response(HLERequestContext& ctx) {
    ctx.WriteBuffer(message);

    IPC::ResponseBuilder rb{ctx, 4};
@@ -109,11 +109,11 @@ void BSD::RecvWork::Response(HLERequestContext& ctx) {
    rb.PushEnum(bsd_errno);
 }

-void BSD::RecvFromWork::Execute(BSD* bsd) {
+void BSD_USA::RecvFromWork::Execute(BSD_USA* bsd) {
    std::tie(ret, bsd_errno) = bsd->RecvFromImpl(fd, flags, message, addr);
 }

-void BSD::RecvFromWork::Response(HLERequestContext& ctx) {
+void BSD_USA::RecvFromWork::Response(HLERequestContext& ctx) {
    ctx.WriteBuffer(message, 0);
    if (!addr.empty()) {
        ctx.WriteBuffer(addr, 1);
@@ -126,29 +126,29 @@ void BSD::RecvFromWork::Response(HLERequestContext& ctx) {
    rb.Push<u32>(static_cast<u32>(addr.size()));
 }

-void BSD::SendWork::Execute(BSD* bsd) {
+void BSD_USA::SendWork::Execute(BSD_USA* bsd) {
    std::tie(ret, bsd_errno) = bsd->SendImpl(fd, flags, message);
 }

-void BSD::SendWork::Response(HLERequestContext& ctx) {
+void BSD_USA::SendWork::Response(HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(ResultSuccess);
    rb.Push<s32>(ret);
    rb.PushEnum(bsd_errno);
 }

-void BSD::SendToWork::Execute(BSD* bsd) {
+void BSD_USA::SendToWork::Execute(BSD_USA* bsd) {
    std::tie(ret, bsd_errno) = bsd->SendToImpl(fd, flags, message, addr);
 }

-void BSD::SendToWork::Response(HLERequestContext& ctx) {
+void BSD_USA::SendToWork::Response(HLERequestContext& ctx) {
    IPC::ResponseBuilder rb{ctx, 4};
    rb.Push(ResultSuccess);
    rb.Push<s32>(ret);
    rb.PushEnum(bsd_errno);
 }

-void BSD::RegisterClient(HLERequestContext& ctx) {
+void BSD_USA::RegisterClient(HLERequestContext& ctx) {
    LOG_WARNING(Service, "(STUBBED) called");

    IPC::ResponseBuilder rb{ctx, 3};
@@ -157,7 +157,7 @@ void BSD::RegisterClient(HLERequestContext& ctx) {
    rb.Push<s32>(0); // bsd errno
 }

-void BSD::StartMonitoring(HLERequestContext& ctx) {
+void BSD_USA::StartMonitoring(HLERequestContext& ctx) {
    LOG_WARNING(Service, "(STUBBED) called");

    IPC::ResponseBuilder rb{ctx, 2};
@@ -165,7 +165,7 @@ void BSD::StartMonitoring(HLERequestContext& ctx) {
    rb.Push(ResultSuccess);
 }

-void BSD::Socket(HLERequestContext& ctx) {
+void BSD_USA::Socket(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const u32 domain = rp.Pop<u32>();
    const u32 type = rp.Pop<u32>();
@@ -181,7 +181,7 @@ void BSD::Socket(HLERequestContext& ctx) {
    rb.PushEnum(bsd_errno);
 }

-void BSD::SocketExempt(HLERequestContext& ctx) {
+void BSD_USA::SocketExempt(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const u32 domain = rp.Pop<u32>();
    const u32 type = rp.Pop<u32>();
@@ -200,7 +200,7 @@ void BSD::SocketExempt(HLERequestContext& ctx) {
    rb.PushEnum(bsd_errno);
 }

-void BSD::Select(HLERequestContext& ctx) {
+void BSD_USA::Select(HLERequestContext& ctx) {
    LOG_DEBUG(Service, "(STUBBED) called");

    IPC::ResponseBuilder rb{ctx, 4};
@@ -210,7 +210,7 @@ void BSD::Select(HLERequestContext& ctx) {
    rb.Push<u32>(0); // bsd errno
 }

-void BSD::Poll(HLERequestContext& ctx) {
+void BSD_USA::Poll(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const s32 nfds = rp.Pop<s32>();
    const s32 timeout = rp.Pop<s32>();
@@ -225,7 +225,7 @@ void BSD::Poll(HLERequestContext& ctx) {
                     });
 }

-void BSD::Accept(HLERequestContext& ctx) {
+void BSD_USA::Accept(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const s32 fd = rp.Pop<s32>();

@@ -237,7 +237,7 @@ void BSD::Accept(HLERequestContext& ctx) {
                     });
 }

-void BSD::Bind(HLERequestContext& ctx) {
+void BSD_USA::Bind(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const s32 fd = rp.Pop<s32>();

@@ -245,7 +245,7 @@ void BSD::Bind(HLERequestContext& ctx) {
    BuildErrnoResponse(ctx, BindImpl(fd, ctx.ReadBuffer()));
 }

-void BSD::Connect(HLERequestContext& ctx) {
+void BSD_USA::Connect(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const s32 fd = rp.Pop<s32>();

@@ -257,7 +257,7 @@ void BSD::Connect(HLERequestContext& ctx) {
                     });
 }

-void BSD::GetPeerName(HLERequestContext& ctx) {
+void BSD_USA::GetPeerName(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const s32 fd = rp.Pop<s32>();

@@ -275,7 +275,7 @@ void BSD::GetPeerName(HLERequestContext& ctx) {
    rb.Push<u32>(static_cast<u32>(write_buffer.size()));
 }

-void BSD::GetSockName(HLERequestContext& ctx) {
+void BSD_USA::GetSockName(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const s32 fd = rp.Pop<s32>();

@@ -293,7 +293,7 @@ void BSD::GetSockName(HLERequestContext& ctx) {
    rb.Push<u32>(static_cast<u32>(write_buffer.size()));
 }

-void BSD::GetSockOpt(HLERequestContext& ctx) {
+void BSD_USA::GetSockOpt(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const s32 fd = rp.Pop<s32>();
    const u32 level = rp.Pop<u32>();
@@ -315,7 +315,7 @@ void BSD::GetSockOpt(HLERequestContext& ctx) {
    rb.Push<u32>(static_cast<u32>(optval.size()));
 }

-void BSD::Listen(HLERequestContext& ctx) {
+void BSD_USA::Listen(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const s32 fd = rp.Pop<s32>();
    const s32 backlog = rp.Pop<s32>();
@@ -325,7 +325,7 @@ void BSD::Listen(HLERequestContext& ctx) {
    BuildErrnoResponse(ctx, ListenImpl(fd, backlog));
 }

-void BSD::Fcntl(HLERequestContext& ctx) {
+void BSD_USA::Fcntl(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const s32 fd = rp.Pop<s32>();
    const s32 cmd = rp.Pop<s32>();
@@ -341,7 +341,7 @@ void BSD::Fcntl(HLERequestContext& ctx) {
    rb.PushEnum(bsd_errno);
 }

-void BSD::SetSockOpt(HLERequestContext& ctx) {
+void BSD_USA::SetSockOpt(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};

    const s32 fd = rp.Pop<s32>();
@@ -355,7 +355,7 @@ void BSD::SetSockOpt(HLERequestContext& ctx) {
    BuildErrnoResponse(ctx, SetSockOptImpl(fd, level, optname, optval));
 }

-void BSD::Shutdown(HLERequestContext& ctx) {
+void BSD_USA::Shutdown(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};

    const s32 fd = rp.Pop<s32>();
@@ -366,7 +366,7 @@ void BSD::Shutdown(HLERequestContext& ctx) {
    BuildErrnoResponse(ctx, ShutdownImpl(fd, how));
 }

-void BSD::Recv(HLERequestContext& ctx) {
+void BSD_USA::Recv(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};

    const s32 fd = rp.Pop<s32>();
@@ -381,7 +381,7 @@ void BSD::Recv(HLERequestContext& ctx) {
                     });
 }

-void BSD::RecvFrom(HLERequestContext& ctx) {
+void BSD_USA::RecvFrom(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};

    const s32 fd = rp.Pop<s32>();
@@ -398,7 +398,7 @@ void BSD::RecvFrom(HLERequestContext& ctx) {
                     });
 }

-void BSD::Send(HLERequestContext& ctx) {
+void BSD_USA::Send(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};

    const s32 fd = rp.Pop<s32>();
@@ -413,7 +413,7 @@ void BSD::Send(HLERequestContext& ctx) {
                     });
 }

-void BSD::SendTo(HLERequestContext& ctx) {
+void BSD_USA::SendTo(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const s32 fd = rp.Pop<s32>();
    const u32 flags = rp.Pop<u32>();
@@ -429,7 +429,7 @@ void BSD::SendTo(HLERequestContext& ctx) {
                     });
 }

-void BSD::Write(HLERequestContext& ctx) {
+void BSD_USA::Write(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const s32 fd = rp.Pop<s32>();

@@ -442,7 +442,7 @@ void BSD::Write(HLERequestContext& ctx) {
                     });
 }

-void BSD::Read(HLERequestContext& ctx) {
+void BSD_USA::Read(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const s32 fd = rp.Pop<s32>();

@@ -454,7 +454,7 @@ void BSD::Read(HLERequestContext& ctx) {
    rb.Push<u32>(0); // bsd errno
 }

-void BSD::Close(HLERequestContext& ctx) {
+void BSD_USA::Close(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const s32 fd = rp.Pop<s32>();

@@ -464,7 +464,7 @@ void BSD::Close(HLERequestContext& ctx) {
 }

 /// @brief Only bsd:s is able to dup()
-void BSD::DuplicateSocket(HLERequestContext& ctx) {
+void BSD_USA::DuplicateSocket(HLERequestContext& ctx) {
    struct InputParameters {
        s32 fd;
        u64 reserved;
@@ -505,7 +505,7 @@ void BSD::DuplicateSocket(HLERequestContext& ctx) {
    }
 }

-void BSD::EventFd(HLERequestContext& ctx) {
+void BSD_USA::EventFd(HLERequestContext& ctx) {
    IPC::RequestParser rp{ctx};
    const u64 initval = rp.Pop<u64>();
    const u32 flags = rp.Pop<u32>();
@@ -516,12 +516,12 @@ void BSD::EventFd(HLERequestContext& ctx) {
 }

 template <typename Work>
-void BSD::ExecuteWork(HLERequestContext& ctx, Work work) {
+void BSD_USA::ExecuteWork(HLERequestContext& ctx, Work work) {
    work.Execute(this);
    work.Response(ctx);
 }

-std::pair<s32, Errno> BSD::SocketImpl(Domain domain, Type type, Protocol protocol) {
+std::pair<s32, Errno> BSD_USA::SocketImpl(Domain domain, Type type, Protocol protocol) {
    // user bsd:u has restrictions on SOCK_SEQPACKET and SOCK_RAW
    if (is_user && (type == Type::SEQPACKET || type == Type::RAW)) {
        if (type == Type::RAW && domain == Domain::INET && protocol == Protocol::ICMP) {
@@ -565,7 +565,7 @@ std::pair<s32, Errno> BSD::SocketImpl(Domain domain, Type type, Protocol protoco
    return {fd, Errno::SUCCESS};
 }

-std::pair<s32, Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std::span<const u8> read_buffer,
+std::pair<s32, Errno> BSD_USA::PollImpl(std::vector<u8>& write_buffer, std::span<const u8> read_buffer,
                                    s32 nfds, s32 timeout) {
    if (nfds <= 0) {
        // When no entries are provided, -1 is returned with errno zero
@@ -632,7 +632,7 @@ std::pair<s32, Errno> BSD::PollImpl(std::vector<u8>& write_buffer, std::span<con
    return Translate(result);
 }

-std::pair<s32, Errno> BSD::AcceptImpl(s32 fd, std::vector<u8>& write_buffer) {
+std::pair<s32, Errno> BSD_USA::AcceptImpl(s32 fd, std::vector<u8>& write_buffer) {
    if (!IsFileDescriptorValid(fd)) {
        return {-1, Errno::BADF};
    }
@@ -660,7 +660,7 @@ std::pair<s32, Errno> BSD::AcceptImpl(s32 fd, std::vector<u8>& write_buffer) {
    return {new_fd, Errno::SUCCESS};
 }

-Errno BSD::BindImpl(s32 fd, std::span<const u8> addr) {
+Errno BSD_USA::BindImpl(s32 fd, std::span<const u8> addr) {
    if (!IsFileDescriptorValid(fd)) {
        return Errno::BADF;
    }
@@ -675,7 +675,7 @@ Errno BSD::BindImpl(s32 fd, std::span<const u8> addr) {
    return Translate(file_descriptors[fd]->socket->Bind(Translate(addr_in)));
 }

-Errno BSD::ConnectImpl(s32 fd, std::span<const u8> addr) {
+Errno BSD_USA::ConnectImpl(s32 fd, std::span<const u8> addr) {
    if (!IsFileDescriptorValid(fd)) {
        return Errno::BADF;
    }
@@ -698,7 +698,7 @@ Errno BSD::ConnectImpl(s32 fd, std::span<const u8> addr) {
    return result;
 }

-Errno BSD::GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer) {
+Errno BSD_USA::GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer) {
    if (!IsFileDescriptorValid(fd)) {
        return Errno::BADF;
    }
@@ -720,7 +720,7 @@ Errno BSD::GetPeerNameImpl(s32 fd, std::vector<u8>& write_buffer) {
    return Translate(bsd_errno);
 }

-Errno BSD::GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer) {
+Errno BSD_USA::GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer) {
    if (!IsFileDescriptorValid(fd)) {
        return Errno::BADF;
    }
@@ -742,7 +742,7 @@ Errno BSD::GetSockNameImpl(s32 fd, std::vector<u8>& write_buffer) {
    return Translate(bsd_errno);
 }

-Errno BSD::ListenImpl(s32 fd, s32 backlog) {
+Errno BSD_USA::ListenImpl(s32 fd, s32 backlog) {
    if (!IsFileDescriptorValid(fd)) {
        return Errno::BADF;
    }
@@ -753,7 +753,7 @@ Errno BSD::ListenImpl(s32 fd, s32 backlog) {
    return Translate(file_descriptors[fd]->socket->Listen(backlog));
 }

-std::pair<s32, Errno> BSD::FcntlImpl(s32 fd, FcntlCmd cmd, s32 arg) {
+std::pair<s32, Errno> BSD_USA::FcntlImpl(s32 fd, FcntlCmd cmd, s32 arg) {
    if (!IsFileDescriptorValid(fd)) {
        return {-1, Errno::BADF};
    }
@@ -783,7 +783,7 @@ std::pair<s32, Errno> BSD::FcntlImpl(s32 fd, FcntlCmd cmd, s32 arg) {
    }
 }

-Errno BSD::GetSockOptImpl(s32 fd, u32 level, OptName optname, std::vector<u8>& optval) {
+Errno BSD_USA::GetSockOptImpl(s32 fd, u32 level, OptName optname, std::vector<u8>& optval) {
    if (!IsFileDescriptorValid(fd)) {
        return Errno::BADF;
    }
@@ -818,7 +818,7 @@ Errno BSD::GetSockOptImpl(s32 fd, u32 level, OptName optname, std::vector<u8>& o
    }
 }

-Errno BSD::SetSockOptImpl(s32 fd, u32 level, OptName optname, std::span<const u8> optval) {
+Errno BSD_USA::SetSockOptImpl(s32 fd, u32 level, OptName optname, std::span<const u8> optval) {
    if (!IsFileDescriptorValid(fd)) {
        return Errno::BADF;
    }
@@ -872,7 +872,7 @@ Errno BSD::SetSockOptImpl(s32 fd, u32 level, OptName optname, std::span<const u8
    }
 }

-Errno BSD::ShutdownImpl(s32 fd, s32 how) {
+Errno BSD_USA::ShutdownImpl(s32 fd, s32 how) {
    if (!IsFileDescriptorValid(fd)) {
        return Errno::BADF;
    }
@@ -884,7 +884,7 @@ Errno BSD::ShutdownImpl(s32 fd, s32 how) {
    return Translate(file_descriptors[fd]->socket->Shutdown(host_how));
 }

-std::pair<s32, Errno> BSD::RecvImpl(s32 fd, u32 flags, std::vector<u8>& message) {
+std::pair<s32, Errno> BSD_USA::RecvImpl(s32 fd, u32 flags, std::vector<u8>& message) {
    if (!IsFileDescriptorValid(fd)) {
        return {-1, Errno::BADF};
    }
@@ -911,7 +911,7 @@ std::pair<s32, Errno> BSD::RecvImpl(s32 fd, u32 flags, std::vector<u8>& message)
    return {ret, bsd_errno};
 }

-std::pair<s32, Errno> BSD::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>& message,
+std::pair<s32, Errno> BSD_USA::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>& message,
                                        std::vector<u8>& addr) {
    if (!IsFileDescriptorValid(fd)) {
        return {-1, Errno::BADF};
@@ -958,7 +958,7 @@ std::pair<s32, Errno> BSD::RecvFromImpl(s32 fd, u32 flags, std::vector<u8>& mess
    return {ret, bsd_errno};
 }

-std::pair<s32, Errno> BSD::SendImpl(s32 fd, u32 flags, std::span<const u8> message) {
+std::pair<s32, Errno> BSD_USA::SendImpl(s32 fd, u32 flags, std::span<const u8> message) {
    if (!IsFileDescriptorValid(fd)) {
        return {-1, Errno::BADF};
    }
@@ -969,7 +969,7 @@ std::pair<s32, Errno> BSD::SendImpl(s32 fd, u32 flags, std::span<const u8> messa
    return Translate(file_descriptors[fd]->socket->Send(message, flags));
 }

-std::pair<s32, Errno> BSD::SendToImpl(s32 fd, u32 flags, std::span<const u8> message,
+std::pair<s32, Errno> BSD_USA::SendToImpl(s32 fd, u32 flags, std::span<const u8> message,
                                      std::span<const u8> addr) {
    if (!IsFileDescriptorValid(fd)) {
        return {-1, Errno::BADF};
@@ -991,7 +991,7 @@ std::pair<s32, Errno> BSD::SendToImpl(s32 fd, u32 flags, std::span<const u8> mes
    return Translate(file_descriptors[fd]->socket->SendTo(flags, message, p_addr_in));
 }

-Errno BSD::CloseImpl(s32 fd) {
+Errno BSD_USA::CloseImpl(s32 fd) {
    if (!IsFileDescriptorValid(fd)) {
        return Errno::BADF;
    }
@@ -1011,7 +1011,7 @@ Errno BSD::CloseImpl(s32 fd) {
    return bsd_errno;
 }

-std::variant<s32, Errno> BSD::DuplicateSocketImpl(s32 fd) {
+std::variant<s32, Errno> BSD_USA::DuplicateSocketImpl(s32 fd) {
    if (!IsFileDescriptorValid(fd)) {
        return Errno::BADF;
    }
@@ -1030,7 +1030,7 @@ std::variant<s32, Errno> BSD::DuplicateSocketImpl(s32 fd) {
    return new_fd;
 }

-std::optional<std::shared_ptr<Network::SocketBase>> BSD::GetSocket(s32 fd) {
+std::optional<std::shared_ptr<Network::SocketBase>> BSD_USA::GetSocket(s32 fd) {
    if (!IsFileDescriptorValid(fd)) {
        return std::nullopt;
    }
@@ -1041,7 +1041,7 @@ std::optional<std::shared_ptr<Network::SocketBase>> BSD::GetSocket(s32 fd) {
    return file_descriptors[fd]->socket;
 }

-s32 BSD::FindFreeFileDescriptorHandle() noexcept {
+s32 BSD_USA::FindFreeFileDescriptorHandle() noexcept {
    for (s32 fd = 0; fd < static_cast<s32>(file_descriptors.size()); ++fd) {
        if (!file_descriptors[fd]) {
            return fd;
@@ -1050,7 +1050,7 @@ s32 BSD::FindFreeFileDescriptorHandle() noexcept {
    return -1;
 }

-bool BSD::IsFileDescriptorValid(s32 fd) const noexcept {
+bool BSD_USA::IsFileDescriptorValid(s32 fd) const noexcept {
    if (fd > static_cast<s32>(MAX_FD) || fd < 0) {
        LOG_ERROR(Service, "Invalid file descriptor handle={}", fd);
        return false;
@@ -1062,7 +1062,7 @@ bool BSD::IsFileDescriptorValid(s32 fd) const noexcept {
    return true;
 }

-void BSD::BuildErrnoResponse(HLERequestContext& ctx, Errno bsd_errno) const noexcept {
+void BSD_USA::BuildErrnoResponse(HLERequestContext& ctx, Errno bsd_errno) const noexcept {
    IPC::ResponseBuilder rb{ctx, 4};

    rb.Push(ResultSuccess);
@@ -1070,7 +1070,7 @@ void BSD::BuildErrnoResponse(HLERequestContext& ctx, Errno bsd_errno) const noex
    rb.PushEnum(bsd_errno);
 }

-void BSD::OnProxyPacketReceived(const Network::ProxyPacket& packet) {
+void BSD_USA::OnProxyPacketReceived(const Network::ProxyPacket& packet) {
    for (auto& optional_descriptor : file_descriptors) {
        if (!optional_descriptor.has_value()) {
            continue;
@@ -1080,43 +1080,43 @@ void BSD::OnProxyPacketReceived(const Network::ProxyPacket& packet) {
    }
 }

-BSD::BSD(Core::System& system_, const char* name, bool is_user_)
+BSD_USA::BSD_USA(Core::System& system_, const char* name, bool is_user_)
    : ServiceFramework{system_, name}
    , is_user{is_user_} {
    // clang-format off
    static const FunctionInfo functions[] = {
-        {0, &BSD::RegisterClient, "RegisterClient"},
-        {1, &BSD::StartMonitoring, "StartMonitoring"},
-        {2, &BSD::Socket, "Socket"},
-        {3, &BSD::SocketExempt, "SocketExempt"},
+        {0, &BSD_USA::RegisterClient, "RegisterClient"},
+        {1, &BSD_USA::StartMonitoring, "StartMonitoring"},
+        {2, &BSD_USA::Socket, "Socket"},
+        {3, &BSD_USA::SocketExempt, "SocketExempt"},
        {4, nullptr, "Open"},
-        {5, &BSD::Select, "Select"},
-        {6, &BSD::Poll, "Poll"},
+        {5, &BSD_USA::Select, "Select"},
+        {6, &BSD_USA::Poll, "Poll"},
        {7, nullptr, "Sysctl"},
-        {8, &BSD::Recv, "Recv"},
-        {9, &BSD::RecvFrom, "RecvFrom"},
-        {10, &BSD::Send, "Send"},
-        {11, &BSD::SendTo, "SendTo"},
-        {12, &BSD::Accept, "Accept"},
-        {13, &BSD::Bind, "Bind"},
-        {14, &BSD::Connect, "Connect"},
-        {15, &BSD::GetPeerName, "GetPeerName"},
-        {16, &BSD::GetSockName, "GetSockName"},
-        {17, &BSD::GetSockOpt, "GetSockOpt"},
-        {18, &BSD::Listen, "Listen"},
+        {8, &BSD_USA::Recv, "Recv"},
+        {9, &BSD_USA::RecvFrom, "RecvFrom"},
+        {10, &BSD_USA::Send, "Send"},
+        {11, &BSD_USA::SendTo, "SendTo"},
+        {12, &BSD_USA::Accept, "Accept"},
+        {13, &BSD_USA::Bind, "Bind"},
+        {14, &BSD_USA::Connect, "Connect"},
+        {15, &BSD_USA::GetPeerName, "GetPeerName"},
+        {16, &BSD_USA::GetSockName, "GetSockName"},
+        {17, &BSD_USA::GetSockOpt, "GetSockOpt"},
+        {18, &BSD_USA::Listen, "Listen"},
        {19, nullptr, "Ioctl"},
-        {20, &BSD::Fcntl, "Fcntl"},
-        {21, &BSD::SetSockOpt, "SetSockOpt"},
-        {22, &BSD::Shutdown, "Shutdown"},
+        {20, &BSD_USA::Fcntl, "Fcntl"},
+        {21, &BSD_USA::SetSockOpt, "SetSockOpt"},
+        {22, &BSD_USA::Shutdown, "Shutdown"},
        {23, nullptr, "ShutdownAllSockets"},
-        {24, &BSD::Write, "Write"},
-        {25, &BSD::Read, "Read"},
-        {26, &BSD::Close, "Close"},
-        {27, &BSD::DuplicateSocket, "DuplicateSocket"},
+        {24, &BSD_USA::Write, "Write"},
+        {25, &BSD_USA::Read, "Read"},
+        {26, &BSD_USA::Close, "Close"},
+        {27, &BSD_USA::DuplicateSocket, "DuplicateSocket"},
        {28, nullptr, "GetResourceStatistics"},
        {29, nullptr, "RecvMMsg"}, //3.0.0+
        {30, nullptr, "SendMMsg"}, //3.0.0+
-        {31, &BSD::EventFd, "EventFd"}, //7.0.0+
+        {31, &BSD_USA::EventFd, "EventFd"}, //7.0.0+
        {32, nullptr, "RegisterResourceStatisticsName"}, //7.0.0+
        {33, nullptr, "RegisterClientShared"}, //10.0.0+
        {34, nullptr, "GetSocketStatistics"}, //15.0.0+
@@ -1144,13 +1144,13 @@ BSD::BSD(Core::System& system_, const char* name, bool is_user_)
    }
 }

-BSD::~BSD() {
+BSD_USA::~BSD_USA() {
    if (auto room_member = Network::GetRoomMember().lock()) {
        room_member->Unbind(proxy_packet_received);
    }
 }

-std::unique_lock<std::mutex> BSD::LockService() noexcept {
+std::unique_lock<std::mutex> BSD_USA::LockService() noexcept {
    return {};
 }

@@ -27,10 +27,10 @@ class Socket;

 namespace Service::Sockets {

-class BSD final : public ServiceFramework<BSD> {
+class BSD_USA final : public ServiceFramework<BSD_USA> {
 public:
-    explicit BSD(Core::System& system_, const char* name, bool is_user);
-    ~BSD() override;
+    explicit BSD_USA(Core::System& system_, const char* name, bool is_user);
+    ~BSD_USA() override;

    // These methods are called from SSL; the first two are also called from
    // this class for the corresponding IPC methods.
@@ -50,7 +50,7 @@ private:
    };

    struct PollWork {
-        void Execute(BSD* bsd);
+        void Execute(BSD_USA* bsd);
        void Response(HLERequestContext& ctx);

        s32 nfds;
@@ -62,7 +62,7 @@ private:
    };

    struct AcceptWork {
-        void Execute(BSD* bsd);
+        void Execute(BSD_USA* bsd);
        void Response(HLERequestContext& ctx);

        s32 fd;
@@ -72,7 +72,7 @@ private:
    };

    struct ConnectWork {
-        void Execute(BSD* bsd);
+        void Execute(BSD_USA* bsd);
        void Response(HLERequestContext& ctx);

        s32 fd;
@@ -81,7 +81,7 @@ private:
    };

    struct RecvWork {
-        void Execute(BSD* bsd);
+        void Execute(BSD_USA* bsd);
        void Response(HLERequestContext& ctx);

        s32 fd;
@@ -92,7 +92,7 @@ private:
    };

    struct RecvFromWork {
-        void Execute(BSD* bsd);
+        void Execute(BSD_USA* bsd);
        void Response(HLERequestContext& ctx);

        s32 fd;
@@ -104,7 +104,7 @@ private:
    };

    struct SendWork {
-        void Execute(BSD* bsd);
+        void Execute(BSD_USA* bsd);
        void Response(HLERequestContext& ctx);

        s32 fd;
@@ -115,7 +115,7 @@ private:
    };

    struct SendToWork {
-        void Execute(BSD* bsd);
+        void Execute(BSD_USA* bsd);
        void Response(HLERequestContext& ctx);

        s32 fd;
@@ -66,9 +66,9 @@ void LoopProcess(Core::System& system) {

    server_manager->RegisterNamedService("ethc:c", std::make_shared<ETHC_C>(system));
    server_manager->RegisterNamedService("ethc:i", std::make_shared<ETHC_I>(system));
-    server_manager->RegisterNamedService("bsd:s", std::make_shared<BSD>(system, "bsd:s", false));
-    server_manager->RegisterNamedService("bsd:u", std::make_shared<BSD>(system, "bsd:u", true));
-    server_manager->RegisterNamedService("bsd:a", std::make_shared<BSD>(system, "bsd:a", true));
+    server_manager->RegisterNamedService("bsd:s", std::make_shared<BSD_USA>(system, "bsd:s", false));
+    server_manager->RegisterNamedService("bsd:u", std::make_shared<BSD_USA>(system, "bsd:u", true));
+    server_manager->RegisterNamedService("bsd:a", std::make_shared<BSD_USA>(system, "bsd:a", true));
    server_manager->RegisterNamedService("bsd:nu", std::make_shared<BSD_NU>(system));
    server_manager->RegisterNamedService("bsdcfg", std::make_shared<BSDCFG>(system, "bsdcfg"));
    server_manager->RegisterNamedService("ifcfg", std::make_shared<BSDCFG>(system, "ifcfg"));
@@ -129,7 +129,7 @@ public:
                LOG_ERROR(Service_SSL,
                          "do_not_close_socket was changed after setting socket; is this right?");
            } else {
-                auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD>("bsd:u");
+                auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD_USA>("bsd:u");
                if (bsd) {
                    auto err = bsd->CloseImpl(fd);
                    if (err != Service::Sockets::Errno::SUCCESS) {
@@ -157,7 +157,7 @@ private:
    Result SetSocketDescriptorImpl(s32* out_fd, s32 fd) {
        LOG_DEBUG(Service_SSL, "called, fd={}", fd);
        ASSERT(!did_handshake);
-        auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD>("bsd:u");
+        auto bsd = system.ServiceManager().GetService<Service::Sockets::BSD_USA>("bsd:u");
        ASSERT_OR_EXECUTE(bsd, { return ResultInternalError; });

        auto const res_v = bsd->DuplicateSocketImpl(fd);
@@ -7,7 +7,7 @@
 #pragma once

 #include <memory>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include "common/common_types.h"
 #include "common/polyfill_thread.h"
@@ -49,7 +49,7 @@ private:
 private:
    Core::System& m_system;
    Container& m_container;
-    ankerl::unordered_dense::map<u64, VsyncManager> m_vsync_managers;
+    ::Common::unordered_map<u64, VsyncManager> m_vsync_managers;
    std::shared_ptr<Core::Timing::EventType> m_event;
    Common::Event m_signal;
    std::jthread m_thread;
@@ -8,7 +8,7 @@
 #include <mutex>
 #include <sstream>
 #include <string>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include <fmt/format.h>
 #include <nlohmann/json.hpp>
@@ -21,8 +21,8 @@
 namespace Core::LaunchTimestampCache {
 namespace {

-using CacheMap = ankerl::unordered_dense::map<u64, s64>;
-using CountMap = ankerl::unordered_dense::map<u64, u64>;
+using CacheMap = ::Common::unordered_map<u64, s64>;
+using CountMap = ::Common::unordered_map<u64, u64>;

 std::mutex g_mutex;
 CacheMap g_cache;
@@ -120,7 +120,6 @@ if (NOT Boost_FOUND)
 endif()

 find_package(fmt 8 CONFIG)
-find_package(unordered_dense REQUIRED)

 if ("arm64" IN_LIST ARCHITECTURE OR DYNARMIC_TESTS)
    find_package(oaknut 2.0.1 CONFIG)
@@ -8,7 +8,6 @@ if (NOT @BUILD_SHARED_LIBS@)
    find_dependency(Boost 1.57)
    find_dependency(fmt 9)
    find_dependency(mcl 0.1.12 EXACT)
-    find_dependency(unordered_dense)

    if ("arm64" IN_LIST ARCHITECTURE)
        find_dependency(oaknut 2.0.1)
@@ -387,7 +387,6 @@ set_target_properties(dynarmic PROPERTIES

 target_compile_options(dynarmic PRIVATE ${DYNARMIC_CXX_FLAGS})

-target_link_libraries(dynarmic PRIVATE unordered_dense::unordered_dense)
 target_link_libraries(dynarmic PUBLIC fmt::fmt common)

 if (BOOST_NO_HEADERS)
@@ -75,7 +75,7 @@ CodePtr AddressSpace::GetOrEmit(IR::LocationDescriptor descriptor) {
    return block_info.entry_point;
 }

-void AddressSpace::InvalidateBasicBlocks(const ankerl::unordered_dense::set<IR::LocationDescriptor>& descriptors) {
+void AddressSpace::InvalidateBasicBlocks(const ::Common::unordered_set<IR::LocationDescriptor>& descriptors) {
    UnprotectCodeMemory();

    for (const auto& descriptor : descriptors) {
@@ -14,7 +14,8 @@
 #include "common/common_types.h"
 #include <oaknut/code_block.hpp>
 #include <oaknut/oaknut.hpp>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
+#include "common/container/unordered_set.h"

 #include "dynarmic/backend/arm64/emit_arm64.h"
 #include "dynarmic/backend/arm64/fastmem.h"
@@ -41,7 +42,7 @@ public:

    CodePtr GetOrEmit(IR::LocationDescriptor descriptor);

-    void InvalidateBasicBlocks(const ankerl::unordered_dense::set<IR::LocationDescriptor>& descriptors);
+    void InvalidateBasicBlocks(const ::Common::unordered_set<IR::LocationDescriptor>& descriptors);

    void ClearCache();
 protected:
@@ -76,9 +77,9 @@ protected:
    // A IR::LocationDescriptor will have one current CodePtr.
    // However, there can be multiple other CodePtrs which are older, previously invalidated blocks.
    std::map<CodePtr, IR::LocationDescriptor> reverse_block_entries;
-    ankerl::unordered_dense::map<IR::LocationDescriptor, CodePtr> block_entries;
-    ankerl::unordered_dense::map<CodePtr, EmittedBlockInfo> block_infos;
-    ankerl::unordered_dense::map<IR::LocationDescriptor, ankerl::unordered_dense::set<CodePtr>> block_references;
+    ::Common::unordered_map<IR::LocationDescriptor, CodePtr> block_entries;
+    ::Common::unordered_map<CodePtr, EmittedBlockInfo> block_infos;
+    ::Common::unordered_map<IR::LocationDescriptor, ::Common::unordered_set<CodePtr>> block_references;

    ExceptionHandler exception_handler;
    FastmemManager fastmem_manager;
@@ -14,7 +14,7 @@
 #include <vector>

 #include "common/common_types.h"
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include "dynarmic/backend/arm64/fastmem.h"
 #include "dynarmic/interface/A32/coprocessor.h"
@@ -105,8 +105,8 @@ struct EmittedBlockInfo {
    CodePtr entry_point;
    std::size_t size;
    std::vector<Relocation> relocations;
-    ankerl::unordered_dense::map<IR::LocationDescriptor, std::vector<BlockRelocation>> block_relocations;
-    ankerl::unordered_dense::map<std::ptrdiff_t, FastmemPatchInfo> fastmem_patch_info;
+    ::Common::unordered_map<IR::LocationDescriptor, std::vector<BlockRelocation>> block_relocations;
+    ::Common::unordered_map<std::ptrdiff_t, FastmemPatchInfo> fastmem_patch_info;
 };

 struct EmitConfig {
@@ -10,7 +10,7 @@

 #include <cstddef>
 #include <tuple>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_set.h"

 #include "dynarmic/mcl/bit.hpp"
 #include "common/common_types.h"
@@ -59,7 +59,7 @@ public:

 private:
    ExceptionHandler& exception_handler;
-    ankerl::unordered_dense::set<DoNotFastmemMarker, DoNotFastmemMarkerHash> do_not_fastmem;
+    ::Common::unordered_set<DoNotFastmemMarker, DoNotFastmemMarkerHash> do_not_fastmem;
 };

 }  // namespace Dynarmic::Backend::Arm64
@@ -18,7 +18,8 @@
 #include "common/common_types.h"
 #include "dynarmic/mcl/is_instance_of_template.hpp"
 #include <oaknut/oaknut.hpp>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
+#include "common/container/unordered_set.h"

 #include "dynarmic/backend/arm64/stack_layout.h"
 #include "dynarmic/ir/cond.h"
@@ -336,7 +337,7 @@ private:
    std::array<HostLocInfo, SpillCount> spills;

    mutable std::size_t alloc_candidate_index = 0;
-    ankerl::unordered_dense::set<const IR::Inst*> defined_insts;
+    ::Common::unordered_set<const IR::Inst*> defined_insts;
 };

 template<typename T>
@@ -11,13 +11,13 @@
 #include <boost/icl/interval_map.hpp>
 #include <boost/icl/interval_set.hpp>
 #include "common/common_types.h"
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_set.h"

 namespace Dynarmic::Backend {

 template<typename P>
 void BlockRangeInformation<P>::AddRange(boost::icl::discrete_interval<P> range, IR::LocationDescriptor location) {
-    block_ranges.add(std::make_pair(range, ankerl::unordered_dense::set<IR::LocationDescriptor>{location}));
+    block_ranges.add(std::make_pair(range, ::Common::unordered_set<IR::LocationDescriptor>{location}));
 }

 template<typename P>
@@ -26,8 +26,8 @@ void BlockRangeInformation<P>::ClearCache() {
 }

 template<typename P>
-ankerl::unordered_dense::set<IR::LocationDescriptor> BlockRangeInformation<P>::InvalidateRanges(const boost::icl::interval_set<P>& ranges) {
-    ankerl::unordered_dense::set<IR::LocationDescriptor> erase_locations;
+::Common::unordered_set<IR::LocationDescriptor> BlockRangeInformation<P>::InvalidateRanges(const boost::icl::interval_set<P>& ranges) {
+    ::Common::unordered_set<IR::LocationDescriptor> erase_locations;
    for (auto invalidate_interval : ranges) {
        auto pair = block_ranges.equal_range(invalidate_interval);
        for (auto it = pair.first; it != pair.second; ++it)
@@ -12,7 +12,8 @@

 #include <boost/icl/interval_map.hpp>
 #include <boost/icl/interval_set.hpp>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
+#include "common/container/unordered_set.h"

 #include "dynarmic/ir/location_descriptor.h"

@@ -23,8 +24,8 @@ class BlockRangeInformation {
 public:
    void AddRange(boost::icl::discrete_interval<P> range, IR::LocationDescriptor location);
    void ClearCache();
-    ankerl::unordered_dense::set<IR::LocationDescriptor> InvalidateRanges(const boost::icl::interval_set<P>& ranges);
-    boost::icl::interval_map<P, ankerl::unordered_dense::set<IR::LocationDescriptor>> block_ranges;
+    ::Common::unordered_set<IR::LocationDescriptor> InvalidateRanges(const boost::icl::interval_set<P>& ranges);
+    boost::icl::interval_map<P, ::Common::unordered_set<IR::LocationDescriptor>> block_ranges;
 };

 }  // namespace Dynarmic::Backend
@@ -17,7 +17,7 @@
 #include <optional>
 #include <shared_mutex>

-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <fmt/format.h>
 #include <sys/mman.h>

@@ -55,7 +55,7 @@ class SigHandler {
        });
    }

-    ankerl::unordered_dense::map<u64, CodeBlockInfo> code_block_infos;
+    ::Common::unordered_map<u64, CodeBlockInfo> code_block_infos;
    std::shared_mutex code_block_infos_mutex;
    struct sigaction old_sa_segv;
    struct sigaction old_sa_bus;
@@ -4,7 +4,7 @@
 #pragma once

 #include "dynarmic/backend/loongarch64/lagoon_cpp.h"
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include "dynarmic/backend/loongarch64/code_block.h"
 #include "dynarmic/backend/loongarch64/emit_loongarch64.h"
@@ -53,8 +53,8 @@ private:
    const A32::UserConfig conf;
    CodeBlock cb;

-    ankerl::unordered_dense::map<u64, CodePtr> block_entries;
-    ankerl::unordered_dense::map<u64, EmittedBlockInfo> block_infos;
+    ::Common::unordered_map<u64, CodePtr> block_entries;
+    ::Common::unordered_map<u64, EmittedBlockInfo> block_infos;

 public:
    struct PreludeInfo {
@@ -9,7 +9,7 @@
 #include <vector>

 #include "dynarmic/backend/loongarch64/lagoon_cpp.h"
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include "common/assert.h"
 #include "common/common_types.h"
@@ -9,7 +9,7 @@
 #pragma once

 #include <biscuit/assembler.hpp>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include "dynarmic/backend/riscv64/code_block.h"
 #include "dynarmic/backend/riscv64/emit_riscv64.h"
@@ -74,8 +74,8 @@ private:
    CodeBlock cb;
    biscuit::Assembler as;

-    ankerl::unordered_dense::map<u64, CodePtr> block_entries;
-    ankerl::unordered_dense::map<u64, EmittedBlockInfo> block_infos;
+    ::Common::unordered_map<u64, CodePtr> block_entries;
+    ::Common::unordered_map<u64, EmittedBlockInfo> block_infos;

    struct PreludeInfo {
        CodePtr end_of_prelude;
@@ -19,7 +19,7 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "dynarmic/mcl/is_instance_of_template.hpp"
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include "dynarmic/backend/riscv64/stack_layout.h"
 #include "dynarmic/ir/cond.h"
@@ -13,7 +13,8 @@
 #include <set>
 #include <tuple>

-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
+#include "common/container/unordered_set.h"

 #include "dynarmic/backend/block_range_information.h"
 #include "dynarmic/backend/x64/a32_jitstate.h"
@@ -126,11 +127,11 @@ public:
    RegAlloc reg_alloc; //reusable reg alloc
    BlockRangeInformation<u32> block_ranges;
    std::array<FastDispatchEntry, fast_dispatch_table_size> fast_dispatch_table;
-    ankerl::unordered_dense::map<u64, FastmemPatchInfo> fastmem_patch_info;
-    ankerl::unordered_dense::map<std::tuple<bool, size_t, int, int>, void (*)()> read_fallbacks;
-    ankerl::unordered_dense::map<std::tuple<bool, size_t, int, int>, void (*)()> write_fallbacks;
-    ankerl::unordered_dense::map<std::tuple<bool, size_t, int, int>, void (*)()> exclusive_write_fallbacks;
-    ankerl::unordered_dense::set<DoNotFastmemMarker> do_not_fastmem;
+    ::Common::unordered_map<u64, FastmemPatchInfo> fastmem_patch_info;
+    ::Common::unordered_map<std::tuple<bool, size_t, int, int>, void (*)()> read_fallbacks;
+    ::Common::unordered_map<std::tuple<bool, size_t, int, int>, void (*)()> write_fallbacks;
+    ::Common::unordered_map<std::tuple<bool, size_t, int, int>, void (*)()> exclusive_write_fallbacks;
+    ::Common::unordered_set<DoNotFastmemMarker> do_not_fastmem;
    boost::container::stable_vector<Xbyak::Label> shared_labels;
    void (*memory_read_128)() = nullptr;   // Dummy
    void (*memory_write_128)() = nullptr;  // Dummy
@@ -12,7 +12,8 @@
 #include <map>
 #include <optional>
 #include <tuple>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
+#include "common/container/unordered_set.h"
 #include <boost/container/static_vector.hpp>

 #include "dynarmic/backend/block_range_information.h"
@@ -122,11 +123,11 @@ public:
    RegAlloc reg_alloc; //reusable reg alloc
    BlockRangeInformation<u64> block_ranges;
    std::array<FastDispatchEntry, fast_dispatch_table_size> fast_dispatch_table;
-    ankerl::unordered_dense::map<u64, FastmemPatchInfo> fastmem_patch_info;
-    ankerl::unordered_dense::map<std::tuple<bool, size_t, int, int>, void (*)()> read_fallbacks;
-    ankerl::unordered_dense::map<std::tuple<bool, size_t, int, int>, void (*)()> write_fallbacks;
-    ankerl::unordered_dense::map<std::tuple<bool, size_t, int, int>, void (*)()> exclusive_write_fallbacks;
-    ankerl::unordered_dense::set<DoNotFastmemMarker> do_not_fastmem;
+    ::Common::unordered_map<u64, FastmemPatchInfo> fastmem_patch_info;
+    ::Common::unordered_map<std::tuple<bool, size_t, int, int>, void (*)()> read_fallbacks;
+    ::Common::unordered_map<std::tuple<bool, size_t, int, int>, void (*)()> write_fallbacks;
+    ::Common::unordered_map<std::tuple<bool, size_t, int, int>, void (*)()> exclusive_write_fallbacks;
+    ::Common::unordered_set<DoNotFastmemMarker> do_not_fastmem;
    boost::container::stable_vector<Xbyak::Label> shared_labels;
    const void* terminal_handler_pop_rsb_hint = nullptr;
    const void* terminal_handler_fast_dispatch_hint = nullptr;
@@ -14,7 +14,7 @@
 #include <utility>

 #include "common/common_types.h"
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include "dynarmic/backend/x64/xbyak.h"

 namespace Dynarmic::Backend::X64 {
@@ -43,7 +43,7 @@ private:
        }
    };

-    ankerl::unordered_dense::map<ConstantT, void*, ConstantHash> constant_info;
+    ::Common::unordered_map<ConstantT, void*, ConstantHash> constant_info;
    std::span<ConstantT> pool;
    std::size_t insertion_point;
 };
@@ -14,7 +14,8 @@
 #include <boost/variant/detail/apply_visitor_binary.hpp>
 #include "dynarmic/mcl/bit.hpp"
 #include "common/common_types.h"
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
+#include "common/container/unordered_set.h"

 #include "dynarmic/backend/x64/block_of_code.h"
 #include "dynarmic/backend/x64/nzcv_util.h"
@@ -396,7 +397,7 @@ void EmitX64::ClearCache() {
    PerfMapClear();
 }

-void EmitX64::InvalidateBasicBlocks(const ankerl::unordered_dense::set<IR::LocationDescriptor>& locations) {
+void EmitX64::InvalidateBasicBlocks(const ::Common::unordered_set<IR::LocationDescriptor>& locations) {
    code.EnableWriting();
    for (const auto& descriptor : locations) {
        if (auto const it = block_descriptors.find(descriptor); it != block_descriptors.end()) {
@@ -16,7 +16,8 @@
 #include <type_traits>
 #include <vector>

-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
+#include "common/container/unordered_set.h"
 #include <boost/container/stable_vector.hpp>
 #include <boost/container/small_vector.hpp>

@@ -88,7 +89,7 @@ public:
    virtual void ClearCache();

    /// Invalidates a selection of basic blocks.
-    void InvalidateBasicBlocks(const ankerl::unordered_dense::set<IR::LocationDescriptor>& locations);
+    void InvalidateBasicBlocks(const ::Common::unordered_set<IR::LocationDescriptor>& locations);

 //protected:
    // Microinstruction emitters
@@ -131,8 +132,8 @@ public:
    // State
    BlockOfCode& code;
    ExceptionHandler exception_handler;
-    ankerl::unordered_dense::map<IR::LocationDescriptor, BlockDescriptor> block_descriptors;
-    ankerl::unordered_dense::map<IR::LocationDescriptor, PatchInformation> patch_information;
+    ::Common::unordered_map<IR::LocationDescriptor, BlockDescriptor> block_descriptors;
+    ::Common::unordered_map<IR::LocationDescriptor, PatchInformation> patch_information;

    // We need materialized protected members
    friend class A64EmitX64;
@@ -4,10 +4,11 @@
 #pragma once

 // You must ensure this matches with src/common/x64/xbyak.h on root dir
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
+#include "common/container/unordered_set.h"
 #include <boost/unordered_map.hpp>
-#define XBYAK_STD_UNORDERED_SET ankerl::unordered_dense::set
-#define XBYAK_STD_UNORDERED_MAP ankerl::unordered_dense::map
+#define XBYAK_STD_UNORDERED_SET ::Common::unordered_set
+#define XBYAK_STD_UNORDERED_MAP ::Common::unordered_map
 #define XBYAK_STD_UNORDERED_MULTIMAP boost::unordered_multimap
 #include <xbyak/xbyak.h>
 #include <xbyak/xbyak_util.h>
@@ -11,7 +11,7 @@
 #include <map>
 #include <bit>

-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include "boost/container/small_vector.hpp"
 #include "dynarmic/frontend/A32/a32_ir_emitter.h"
 #include "dynarmic/frontend/A32/a32_location_descriptor.h"
@@ -1433,7 +1433,7 @@ static void VerificationPass(const IR::Block& block) {
            ASSERT(IR::AreTypesCompatible(t1, t2));
        }
    }
-    ankerl::unordered_dense::map<IR::Inst*, size_t> actual_uses;
+    ::Common::unordered_map<IR::Inst*, size_t> actual_uses;
    for (auto const& inst : block.instructions) {
        for (size_t i = 0; i < inst.NumArgs(); i++)
            if (IR::Value const arg = inst.GetArg(i); !arg.IsImmediate())
@@ -8,7 +8,7 @@

 #include <array>
 #include <exception>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include <catch2/catch_test_macros.hpp>
 #include "common/common_types.h"
@@ -23,7 +23,7 @@ namespace {
 class MyEnvironment final : public A64::UserCallbacks {
 public:
    u64 ticks_left = 0;
-    ankerl::unordered_dense::map<u64, u8> memory{};
+    ::Common::unordered_map<u64, u8> memory{};

    u8 MemoryRead8(u64 vaddr) override {
        return memory[vaddr];
@@ -8,7 +8,7 @@

 #pragma once

-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "dynarmic/interface/A64/a64.h"
@@ -17,7 +17,7 @@ using Vector = Dynarmic::A64::Vector;

 class A64TestEnv : public Dynarmic::A64::UserCallbacks {
 public:
-    ankerl::unordered_dense::map<u64, u8> modified_memory;
+    ::Common::unordered_map<u64, u8> modified_memory;
    std::vector<u32> code_mem;
    u64 ticks_left = 0;
    u64 code_mem_start_address = 0;
@@ -24,7 +24,7 @@ add_executable(dynarmic_tests
    A64/real_world.cpp
    A64/testenv.h
 )
-target_link_libraries(dynarmic_tests PRIVATE merry::oaknut unordered_dense::unordered_dense)
+target_link_libraries(dynarmic_tests PRIVATE merry::oaknut)

 if (DYNARMIC_TESTS_USE_UNICORN)
    target_link_libraries(dynarmic_tests PRIVATE Unicorn::Unicorn)
@@ -72,7 +72,7 @@ add_executable(dynarmic_print_info
    print_info.cpp
 )
 create_target_directory_groups(dynarmic_print_info)
-target_link_libraries(dynarmic_print_info PRIVATE dynarmic fmt::fmt unordered_dense::unordered_dense)
+target_link_libraries(dynarmic_print_info PRIVATE dynarmic fmt::fmt)
 if (BOOST_NO_HEADERS)
    target_link_libraries(dynarmic_print_info PRIVATE Boost::variant Boost::icl Boost::pool)
 else()
@@ -93,7 +93,7 @@ add_executable(dynarmic_test_generator

 create_target_directory_groups(dynarmic_test_generator)

-target_link_libraries(dynarmic_test_generator PRIVATE dynarmic fmt::fmt unordered_dense::unordered_dense)
+target_link_libraries(dynarmic_test_generator PRIVATE dynarmic fmt::fmt)
 if (BOOST_NO_HEADERS)
    target_link_libraries(dynarmic_test_generator PRIVATE Boost::variant Boost::icl Boost::pool)
 else()
@@ -110,7 +110,7 @@ add_executable(dynarmic_test_reader
    test_reader.cpp
 )
 create_target_directory_groups(dynarmic_test_reader)
-target_link_libraries(dynarmic_test_reader PRIVATE dynarmic fmt::fmt unordered_dense::unordered_dense)
+target_link_libraries(dynarmic_test_reader PRIVATE dynarmic fmt::fmt)
 if (BOOST_NO_HEADERS)
    target_link_libraries(dynarmic_test_reader PRIVATE Boost::variant Boost::icl Boost::pool)
 else()
@@ -123,7 +123,7 @@ target_compile_definitions(dynarmic_test_reader PRIVATE FMT_USE_USER_DEFINED_LIT
 #
 create_target_directory_groups(dynarmic_tests)

-target_link_libraries(dynarmic_tests PRIVATE dynarmic Catch2::Catch2WithMain fmt::fmt unordered_dense::unordered_dense)
+target_link_libraries(dynarmic_tests PRIVATE dynarmic Catch2::Catch2WithMain fmt::fmt)
 if (BOOST_NO_HEADERS)
    target_link_libraries(dynarmic_tests PRIVATE Boost::variant Boost::icl Boost::pool)
 else()
@@ -11,7 +11,7 @@
 #include <memory>
 #include <mutex>
 #include <optional>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -185,7 +185,7 @@ private:

    mutable std::mutex mutex;
    mutable std::mutex callback_mutex;
-    ankerl::unordered_dense::map<int, ConsoleUpdateCallback> callback_list;
+    ::Common::unordered_map<int, ConsoleUpdateCallback> callback_list;
    int last_callback_key = 0;

    // Stores the current status of all console input
@@ -14,7 +14,7 @@
 #include <vector>
 #include <atomic>

-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include "common/common_types.h"
 #include "common/input.h"
@@ -636,7 +636,7 @@ private:
    ControllerMotionDevices virtual_motion_devices;

    mutable std::mutex callback_mutex;
-    ankerl::unordered_dense::map<int, ControllerUpdateCallback> callback_list;
+    ::Common::unordered_map<int, ControllerUpdateCallback> callback_list;
    int last_callback_key = 0;

    // Stores the current status of all controller input
@@ -10,7 +10,7 @@
 #include <functional>
 #include <memory>
 #include <mutex>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <vector>

 #include "common/common_types.h"
@@ -205,7 +205,7 @@ private:

    mutable std::mutex mutex;
    mutable std::mutex callback_mutex;
-    ankerl::unordered_dense::map<int, InterfaceUpdateCallback> callback_list;
+    ::Common::unordered_map<int, InterfaceUpdateCallback> callback_list;
    int last_callback_key = 0;

    // Stores the current status of all external device input
@@ -90,7 +90,7 @@ public:
    Common::Input::ButtonNames GetUIName(const Common::ParamPackage& params) const override;

 private:
-    ankerl::unordered_dense::map<PadIdentifier, jobject> input_devices;
+    ::Common::unordered_map<PadIdentifier, jobject> input_devices;

    /// Returns the correct identifier corresponding to the player index
    PadIdentifier GetIdentifier(const std::string& guid, size_t port) const;
@@ -732,7 +732,7 @@ SDLDriver::~SDLDriver() {

 std::vector<Common::ParamPackage> SDLDriver::GetInputDevices() const {
    std::vector<Common::ParamPackage> devices;
-    ankerl::unordered_dense::map<int, std::shared_ptr<SDLJoystick>> joycon_pairs;
+    ::Common::unordered_map<int, std::shared_ptr<SDLJoystick>> joycon_pairs;
    for (const auto& [key, value] : joystick_map) {
        for (const auto& joystick : value) {
            if (!joystick->GetSDLJoystick()) {
@@ -9,7 +9,7 @@
 #include <atomic>
 #include <mutex>
 #include <thread>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include <SDL3/SDL.h>

@@ -117,7 +117,7 @@ private:
    Common::SPSCQueue<VibrationRequest> vibration_queue;

    /// Map of GUID of a list of corresponding virtual Joysticks
-    ankerl::unordered_dense::map<Common::UUID, std::vector<std::shared_ptr<SDLJoystick>>> joystick_map;
+    ::Common::unordered_map<Common::UUID, std::vector<std::shared_ptr<SDLJoystick>>> joystick_map;
    std::mutex joystick_map_mutex;

    bool start_thread = false;
@@ -8,7 +8,7 @@

 #include <functional>
 #include <mutex>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include "common/common_types.h"
 #include "common/input.h"
@@ -270,10 +270,10 @@ protected:

 private:
    struct ControllerData {
-        ankerl::unordered_dense::map<int, bool> buttons;
-        ankerl::unordered_dense::map<int, u8> hat_buttons;
-        ankerl::unordered_dense::map<int, float> axes;
-        ankerl::unordered_dense::map<int, BasicMotion> motions;
+        ::Common::unordered_map<int, bool> buttons;
+        ::Common::unordered_map<int, u8> hat_buttons;
+        ::Common::unordered_map<int, float> axes;
+        ::Common::unordered_map<int, BasicMotion> motions;
        Common::Input::BatteryLevel battery{};
        Common::Input::BodyColorStatus color{};
        Common::Input::CameraStatus camera{};
@@ -301,8 +301,8 @@ private:
    bool configuring{false};
    const std::string input_engine;
    int last_callback_key = 0;
-    ankerl::unordered_dense::map<PadIdentifier, ControllerData> controller_list;
-    ankerl::unordered_dense::map<int, InputIdentifier> callback_list;
+    ::Common::unordered_map<PadIdentifier, ControllerData> controller_list;
+    ::Common::unordered_map<int, InputIdentifier> callback_list;
    MappingCallback mapping_callback;
 };

@@ -8,7 +8,7 @@

 #include <memory>
 #include <string>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <vector>

 namespace Common {
@@ -56,9 +56,9 @@ enum class InputType { None, Button, Stick, Motion, Touch };
 * Given a ParamPackage for a Device returned from `GetInputDevices`, attempt to get the default
 * mapping for the device.
 */
-using AnalogMapping = ankerl::unordered_dense::map<Settings::NativeAnalog::Values, Common::ParamPackage>;
-using ButtonMapping = ankerl::unordered_dense::map<Settings::NativeButton::Values, Common::ParamPackage>;
-using MotionMapping = ankerl::unordered_dense::map<Settings::NativeMotion::Values, Common::ParamPackage>;
+using AnalogMapping = ::Common::unordered_map<Settings::NativeAnalog::Values, Common::ParamPackage>;
+using ButtonMapping = ::Common::unordered_map<Settings::NativeButton::Values, Common::ParamPackage>;
+using MotionMapping = ::Common::unordered_map<Settings::NativeMotion::Values, Common::ParamPackage>;

 class InputSubsystem {
 public:
@@ -440,8 +440,7 @@ void SetupCapabilities(const Profile& profile, const Info& info, EmitContext& ct
    }
    if ((info.uses_subgroup_vote || info.uses_subgroup_invocation_id ||
         info.uses_subgroup_shuffles) &&
-        profile.support_vote &&
-        (ctx.stage != Stage::Geometry || profile.support_subgroup_in_geometry_stage)) {
+        profile.support_vote && profile.SupportsSubgroupStage(ctx.stage)) {
        ctx.AddCapability(spv::Capability::GroupNonUniformBallot);
        ctx.AddCapability(spv::Capability::GroupNonUniformShuffle);
        if (!profile.warp_size_potentially_larger_than_guest) {
@@ -13,18 +13,6 @@ Id SubgroupScope(EmitContext& ctx) {
    return ctx.Const(static_cast<u32>(spv::Scope::Subgroup));
 }

-// Some mobile GPUs (e.g. Adreno/Turnip) only advertise subgroup ballot/shuffle support for the
-// fragment and compute stages (VkPhysicalDeviceSubgroupProperties::supportedStages), even though
-// they support these operations elsewhere. Guest shaders that use VOTE/SHFL in a geometry program
-// would otherwise emit GroupNonUniform* SPIR-V the driver never declared support for in that
-// stage. There is no barrier in the geometry stage, so a real cross-invocation emulation can't be
-// made correct; instead, treat the current invocation as if it were alone in its subgroup. This is
-// semantically wrong for guest code that relies on genuine cross-lane communication, but it is
-// well-defined, valid SPIR-V that doesn't depend on unsupported hardware capabilities.
-bool NeedsGeometrySubgroupFallback(EmitContext& ctx) {
-    return ctx.stage == Stage::Geometry && !ctx.profile.support_subgroup_in_geometry_stage;
-}
-
 bool StageSupportsSubgroups(EmitContext& ctx) {
    return ctx.profile.SupportsSubgroupStage(ctx.stage);
 }
@@ -106,9 +94,6 @@ Id AddPartitionBase(EmitContext& ctx, Id thread_id) {
 } // Anonymous namespace

 Id EmitLaneId(EmitContext& ctx) {
-    if (NeedsGeometrySubgroupFallback(ctx)) {
-        return ctx.u32_zero_value;
-    }
    const Id id{GetThreadId(ctx)};
    if (!ctx.profile.warp_size_potentially_larger_than_guest) {
        return id;
@@ -117,9 +102,6 @@ Id EmitLaneId(EmitContext& ctx) {
 }

 Id EmitVoteAll(EmitContext& ctx, Id pred) {
-    if (NeedsGeometrySubgroupFallback(ctx)) {
-        return pred;
-    }
    if (!StageSupportsSubgroups(ctx)) {
        return pred;
    }
@@ -136,9 +118,6 @@ Id EmitVoteAll(EmitContext& ctx, Id pred) {
 }

 Id EmitVoteAny(EmitContext& ctx, Id pred) {
-    if (NeedsGeometrySubgroupFallback(ctx)) {
-        return pred;
-    }
    if (!StageSupportsSubgroups(ctx)) {
        return pred;
    }
@@ -155,9 +134,6 @@ Id EmitVoteAny(EmitContext& ctx, Id pred) {
 }

 Id EmitVoteEqual(EmitContext& ctx, Id pred) {
-    if (NeedsGeometrySubgroupFallback(ctx)) {
-        return ctx.true_value;
-    }
    if (!StageSupportsSubgroups(ctx)) {
        return ctx.true_value;
    }
@@ -175,16 +151,6 @@ Id EmitVoteEqual(EmitContext& ctx, Id pred) {
 }

 Id EmitSubgroupBallot(EmitContext& ctx, Id pred) {
-    if (NeedsGeometrySubgroupFallback(ctx)) {
-        // Reflect only this invocation's own predicate. There is no way to observe other
-        // invocations' predicates without real subgroup hardware support in this stage, so this
-        // is a best-effort approximation: it keeps any branch gated on "did anyone match" live
-        // (rather than letting the SPIR-V optimizer prove it dead, which previously caused
-        // indirect draws fed by this shader to see indexCount=instanceCount=0), but any downstream
-        // math that assumes a real cross-lane population count (e.g. popcount-based compaction
-        // offsets) will not be correct.
-        return ctx.OpSelect(ctx.U32[1], pred, ctx.Const(1U), ctx.u32_zero_value);
-    }
    if (!StageSupportsSubgroups(ctx)) {
        return ctx.OpSelect(ctx.U32[1], pred, ctx.Const(1u), ctx.u32_zero_value);
    }
@@ -196,9 +162,6 @@ Id EmitSubgroupBallot(EmitContext& ctx, Id pred) {
 }

 Id EmitSubgroupEqMask(EmitContext& ctx) {
-    if (NeedsGeometrySubgroupFallback(ctx)) {
-        return ctx.Const(1U);
-    }
    if (!StageSupportsSubgroups(ctx)) {
        return ctx.Const(1u);
    }
@@ -206,9 +169,6 @@ Id EmitSubgroupEqMask(EmitContext& ctx) {
 }

 Id EmitSubgroupLtMask(EmitContext& ctx) {
-    if (NeedsGeometrySubgroupFallback(ctx)) {
-        return ctx.u32_zero_value;
-    }
    if (!StageSupportsSubgroups(ctx)) {
        return ctx.u32_zero_value;
    }
@@ -216,9 +176,6 @@ Id EmitSubgroupLtMask(EmitContext& ctx) {
 }

 Id EmitSubgroupLeMask(EmitContext& ctx) {
-    if (NeedsGeometrySubgroupFallback(ctx)) {
-        return ctx.Const(1U);
-    }
    if (!StageSupportsSubgroups(ctx)) {
        return ctx.Const(1u);
    }
@@ -226,9 +183,6 @@ Id EmitSubgroupLeMask(EmitContext& ctx) {
 }

 Id EmitSubgroupGtMask(EmitContext& ctx) {
-    if (NeedsGeometrySubgroupFallback(ctx)) {
-        return ctx.u32_zero_value;
-    }
    if (!StageSupportsSubgroups(ctx)) {
        return ctx.u32_zero_value;
    }
@@ -236,9 +190,6 @@ Id EmitSubgroupGtMask(EmitContext& ctx) {
 }

 Id EmitSubgroupGeMask(EmitContext& ctx) {
-    if (NeedsGeometrySubgroupFallback(ctx)) {
-        return ctx.Const(1U);
-    }
    if (!StageSupportsSubgroups(ctx)) {
        return ctx.Const(1u);
    }
@@ -247,10 +198,6 @@ Id EmitSubgroupGeMask(EmitContext& ctx) {

 Id EmitShuffleIndex(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                    Id segmentation_mask) {
-    if (NeedsGeometrySubgroupFallback(ctx)) {
-        SetInBoundsFlag(inst, ctx.false_value);
-        return value;
-    }
    const Id not_seg_mask{ctx.OpNot(ctx.U32[1], segmentation_mask)};
    const Id thread_id{EmitLaneId(ctx)};
    const Id min_thread_id{ComputeMinThreadId(ctx, thread_id, segmentation_mask)};
@@ -270,10 +217,6 @@ Id EmitShuffleIndex(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id cla

 Id EmitShuffleUp(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                 Id segmentation_mask) {
-    if (NeedsGeometrySubgroupFallback(ctx)) {
-        SetInBoundsFlag(inst, ctx.false_value);
-        return value;
-    }
    const Id thread_id{EmitLaneId(ctx)};
    const Id max_thread_id{GetMaxThreadId(ctx, thread_id, clamp, segmentation_mask)};
    Id src_thread_id{ctx.OpISub(ctx.U32[1], thread_id, index)};
@@ -289,10 +232,6 @@ Id EmitShuffleUp(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,

 Id EmitShuffleDown(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                   Id segmentation_mask) {
-    if (NeedsGeometrySubgroupFallback(ctx)) {
-        SetInBoundsFlag(inst, ctx.false_value);
-        return value;
-    }
    const Id thread_id{EmitLaneId(ctx)};
    const Id max_thread_id{GetMaxThreadId(ctx, thread_id, clamp, segmentation_mask)};
    Id src_thread_id{ctx.OpIAdd(ctx.U32[1], thread_id, index)};
@@ -308,10 +247,6 @@ Id EmitShuffleDown(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clam

 Id EmitShuffleButterfly(EmitContext& ctx, IR::Inst* inst, Id value, Id index, Id clamp,
                        Id segmentation_mask) {
-    if (NeedsGeometrySubgroupFallback(ctx)) {
-        SetInBoundsFlag(inst, ctx.false_value);
-        return value;
-    }
    const Id thread_id{EmitLaneId(ctx)};
    const Id max_thread_id{GetMaxThreadId(ctx, thread_id, clamp, segmentation_mask)};
    Id src_thread_id{ctx.OpBitwiseXor(ctx.U32[1], thread_id, index)};
@@ -1455,14 +1455,13 @@ void EmitContext::DefineInputs(const IR::Program& program) {
    if (info.uses_is_helper_invocation) {
        is_helper_invocation = DefineInput(*this, U1, false, spv::BuiltIn::HelperInvocation);
    }
-    if (info.uses_subgroup_mask &&
-        (stage != Stage::Geometry || profile.support_subgroup_in_geometry_stage)) {
+    if (info.uses_subgroup_mask && profile.SupportsSubgroupStage(stage)) {
        subgroup_mask_eq = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupEqMaskKHR);
        subgroup_mask_lt = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupLtMaskKHR);
        subgroup_mask_le = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupLeMaskKHR);
        subgroup_mask_gt = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupGtMaskKHR);
        subgroup_mask_ge = DefineInput(*this, U32[4], false, spv::BuiltIn::SubgroupGeMaskKHR);
-        if (profile.support_explicit_workgroup_layout) {
+        if (stage == Stage::Fragment) {
            Decorate(subgroup_mask_eq, spv::Decoration::Flat);
            Decorate(subgroup_mask_lt, spv::Decoration::Flat);
            Decorate(subgroup_mask_le, spv::Decoration::Flat);
@@ -1470,11 +1469,10 @@ void EmitContext::DefineInputs(const IR::Program& program) {
            Decorate(subgroup_mask_ge, spv::Decoration::Flat);
        }
    }
-    if (info.uses_fswzadd ||
-        ((info.uses_subgroup_invocation_id || info.uses_subgroup_shuffles ||
-          (profile.warp_size_potentially_larger_than_guest &&
-           (info.uses_subgroup_vote || info.uses_subgroup_mask))) &&
-         (stage != Stage::Geometry || profile.support_subgroup_in_geometry_stage))) {
+    if ((info.uses_fswzadd || info.uses_subgroup_invocation_id || info.uses_subgroup_shuffles ||
+         (profile.warp_size_potentially_larger_than_guest &&
+          (info.uses_subgroup_vote || info.uses_subgroup_mask))) &&
+        profile.SupportsSubgroupStage(stage)) {
        AddCapability(spv::Capability::GroupNonUniform);
        subgroup_local_invocation_id =
            DefineInput(*this, U32[1], false, spv::BuiltIn::SubgroupLocalInvocationId);
@@ -9,7 +9,7 @@
 #include <array>

 #include <sirit/sirit.h>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_set.h"

 #include "shader_recompiler/backend/bindings.h"
 #include "shader_recompiler/frontend/ir/program.h"
@@ -370,7 +370,7 @@ public:
    Id load_const_func_u32x4{};

    // Sirit::Id doesn't play nice with *::set<>
-    ankerl::unordered_dense::set<u32> non_uniform_ids;
+    ::Common::unordered_set<u32> non_uniform_ids;

    bool uses_nonuniform_sampled_image{};
    bool uses_nonuniform_storage_image{};
@@ -7,7 +7,7 @@
 #pragma once

 #include <array>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"

 #include "common/common_types.h"
 #include "shader_recompiler/program_header.h"
@@ -126,9 +126,9 @@ protected:
    u32 start_address{};
    bool is_proprietary_driver{};
 public:
-    ankerl::unordered_dense::map<CbufWordKey, u32, CbufWordKeyHash> cbuf_word_cache;
-    ankerl::unordered_dense::map<HandleKey,  u32, HandleKeyHash> handle_cache;
-    ankerl::unordered_dense::map<const IR::Inst*, ConstBufferAddr> track_cache;
+    ::Common::unordered_map<CbufWordKey, u32, CbufWordKeyHash> cbuf_word_cache;
+    ::Common::unordered_map<HandleKey,  u32, HandleKeyHash> handle_cache;
+    ::Common::unordered_map<const IR::Inst*, ConstBufferAddr> track_cache;
 };

 } // namespace Shader
@@ -7,7 +7,7 @@
 #include <algorithm>
 #include <memory>
 #include <string>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <utility>
 #include <vector>

@@ -390,7 +390,7 @@ private:
                   std::optional<Node> return_label) {
        Statement* const false_stmt{pool.Create(Identity{}, IR::Condition{false}, &root_stmt)};
        Tree& root{root_stmt.children};
-        ankerl::unordered_dense::map<Flow::Block*, Node> local_labels;
+        ::Common::unordered_map<Flow::Block*, Node> local_labels;
        local_labels.reserve(function.blocks.size());

        for (Flow::Block& block : function.blocks) {
@@ -19,7 +19,7 @@
 #include <deque>
 #include <map>
 #include <span>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <variant>
 #include <vector>

@@ -7,7 +7,7 @@
 #include <algorithm>
 #include <bit>
 #include <optional>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <tuple>
 #include <limits>
 #include <boost/container/small_vector.hpp>
@@ -41,12 +41,6 @@ struct Profile {
    bool support_quad_shuffles{};
    bool support_vote{};
    u32 supported_subgroup_stages{0x7F};
-    bool support_subgroup_in_geometry_stage{}; ///< True when the device advertises subgroup
-                                               ///< ballot/shuffle support for VK_SHADER_STAGE_GEOMETRY_BIT
-                                               ///< (VkPhysicalDeviceSubgroupProperties::supportedStages).
-                                               ///< Many mobile GPUs support subgroup ops only in
-                                               ///< fragment/compute; guest shaders using VOTE/SHFL in a
-                                               ///< geometry program need a non-subgroup fallback there.
    bool support_viewport_index_layer_non_geometry{};
    bool support_viewport_mask{};
    bool support_typeless_image_loads{};
@@ -11,7 +11,7 @@
 #include <mutex>
 #include <stdexcept>
 #include <thread>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <vector>

 #include <catch2/catch_test_macros.hpp>
@@ -39,7 +39,7 @@ public:

 private:
    mutable std::mutex mutex;
-    ankerl::unordered_dense::map<std::thread::id, u32> ids;
+    ::Common::unordered_map<std::thread::id, u32> ids;
 };

 class TestControl1 {
@@ -3,7 +3,7 @@

 #include <memory>
 #include <stdexcept>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <tuple>
 #include <vector>
 #include <optional>
@@ -65,7 +65,7 @@ public:
    }

 private:
-    ankerl::unordered_dense::map<u64, int> page_table;
+    ::Common::unordered_map<u64, int> page_table;
    std::vector<std::tuple<DAddr, u64, int>> calls;
    size_t update_calls = 0;
 };
@@ -16,7 +16,7 @@
 #include <span>
 #include <vector>

-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_map.h"
 #include <boost/container/static_vector.hpp>
 #include <boost/container/small_vector.hpp>

@@ -11,7 +11,7 @@
 #include <deque>
 #include <limits>
 #include <type_traits>
-#include <ankerl/unordered_dense.h>
+#include "common/container/unordered_set.h"
 #include <utility>

 #include "common/alignment.h"
@@ -257,7 +257,7 @@ private:
    std::array<Manager*, NUM_HIGH_PAGES> top_tier{};
    std::deque<std::array<Manager, MANAGER_POOL_SIZE>> manager_pool;
    std::deque<Manager*> free_managers;
-    ankerl::unordered_dense::set<u32> cached_pages;
+    ::Common::unordered_set<u32> cached_pages;
    DeviceTracker* device_tracker = nullptr;
 };

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
lizzie	8d0ba9e042	BSD macro too	2026-08-31 18:03:33 +00:00
lizzie	591c7f4456	Fix license headers	2026-08-31 03:58:49 +00:00
lizzie	d762bc54d4	[video_core/buffer_cache] fix PAGE_SHIFT macro clash on FBSD Signed-off-by: lizzie <lizzie@eden-emu.dev>	2026-08-31 03:43:50 +00:00
xbzk	b7f0f98519	[android] expose log filter setting (#4327 ) - [x] I have read and followed the [Contribution Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/CONTRIBUTING.md#code-contributions). - [x] I have read and followed the [AI Policy](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/AI.md) - [x] I have read and followed the [Coding Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/Coding.md) to the best of my ability. ------------------- Takes log filter to android and fixes qt "loads after setting, but ignore in next runs" issue Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4327 Reviewed-by: Lizzie and Samuel <lizzie@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-08-31 04:22:15 +02:00
crueter	7fda6dde73	[common] Switch to boost::unordered_flat containers (#4326 ) Replaces all instances of ankerl's unordered map/set with boost's `unordered_flat_*` classes. This uses std::hash since boost::hash is actually a lot slower. Also adds an abstraction layer in `Common` so future changes are quicker and easier. Other implementation details: - ankerl provided hash specializations for tuple and pair, so those were ported here - std::erase_if doesn't work on boost, so just used the ADL'd erase_if This should be about equal or superior performance as unordered_dense for everything except iteration. Signed-off-by: crueter <crueter@eden-emu.dev> - [x] I have read and followed the [Contribution Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/CONTRIBUTING.md#code-contributions). - [x] I have read and followed the [AI Policy](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/AI.md) - [x] I have read and followed the [Coding Guidelines](https://git.eden-emu.dev/eden-emu/eden/src/branch/master/docs/policies/Coding.md) to the best of my ability. ------------------- Reviewed-on: https://git.eden-emu.dev/eden-emu/eden/pulls/4326 Reviewed-by: Lizzie and Samuel <lizzie@eden-emu.dev> Reviewed-by: MaranBr <maranbr@eden-emu.dev>	2026-08-31 02:58:09 +02:00