Robin map and robin set implemented

Robin map and robin set implemented, like Skyline, for more performance.

.gitmodules

@@ -58,3 +58,6 @@
 [submodule "VulkanMemoryAllocator"]
 	path = externals/VulkanMemoryAllocator
 	url = https://github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator.git
+[submodule "robin-map"]
+	path = externals/robin-map
+	url = https://github.com/Tessil/robin-map

externals/CMakeLists.txt

@@ -14,6 +14,9 @@ set(BUILD_SHARED_LIBS OFF)
 # Skip install rules for all externals
 set_directory_properties(PROPERTIES EXCLUDE_FROM_ALL ON)
 
+# Robin-map
+add_subdirectory(robin-map)
+
 # xbyak
 if ((ARCHITECTURE_x86 OR ARCHITECTURE_x86_64) AND NOT TARGET xbyak::xbyak)
     add_subdirectory(xbyak)

src/android/app/src/main/jni/native.cpp

@@ -529,7 +529,7 @@ private:
     static EmulationSession s_instance;
 
     // Frontend management
-    std::unordered_map<std::string, RomMetadata> m_rom_metadata_cache;
+    tsl::robin_map<std::string, RomMetadata> m_rom_metadata_cache;
 
     // Window management
     std::unique_ptr<EmuWindow_Android> m_window;

src/common/fs/path_util.cpp

@@ -3,7 +3,7 @@
 
 #include <algorithm>
 #include <sstream>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 
 #include "common/fs/fs.h"
 #ifdef ANDROID
@@ -141,7 +141,7 @@ private:
         SetYuzuPathImpl(yuzu_path, new_path);
     }
 
-    std::unordered_map<YuzuPath, fs::path> yuzu_paths;
+    tsl::robin_map<YuzuPath, fs::path> yuzu_paths;
 };
 
 bool ValidatePath(const fs::path& path) {

src/common/host_memory.cpp

@@ -4,8 +4,9 @@
 #ifdef _WIN32
 
 #include <iterator>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <boost/icl/separate_interval_set.hpp>
+
 #include <windows.h>
 #include "common/dynamic_library.h"
 
@@ -348,7 +349,7 @@ private:
 
     std::mutex placeholder_mutex;                                 ///< Mutex for placeholders
     boost::icl::separate_interval_set<size_t> placeholders;       ///< Mapped placeholders
-    std::unordered_map<size_t, size_t> placeholder_host_pointers; ///< Placeholder backing offset
+    tsl::robin_map<size_t, size_t> placeholder_host_pointers; ///< Placeholder backing offset
 };
 
 #elif defined(__linux__) || defined(__FreeBSD__) // ^^^ Windows ^^^ vvv Linux vvv

src/common/input.h

@@ -6,9 +6,10 @@
 #include <functional>
 #include <memory>
 #include <string>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <utility>
 #include <vector>
+
 #include "common/logging/log.h"
 #include "common/param_package.h"
 #include "common/uuid.h"
@@ -409,7 +410,7 @@ public:
 namespace Impl {
 
 template <typename InputDeviceType>
-using FactoryListType = std::unordered_map<std::string, std::shared_ptr<Factory<InputDeviceType>>>;
+using FactoryListType = tsl::robin_map<std::string, std::shared_ptr<Factory<InputDeviceType>>>;
 
 template <typename InputDeviceType>
 struct FactoryList {

src/common/param_package.h

@@ -5,14 +5,14 @@
 
 #include <initializer_list>
 #include <string>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 
 namespace Common {
 
 /// A string-based key-value container supporting serializing to and deserializing from a string
 class ParamPackage {
 public:
-    using DataType = std::unordered_map<std::string, std::string>;
+    using DataType = tsl::robin_map<std::string, std::string>;
 
     ParamPackage() = default;
     explicit ParamPackage(const std::string& serialized);

src/core/arm/dynarmic/arm_dynarmic_32.h

@@ -5,7 +5,7 @@
 
 #include <atomic>
 #include <memory>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 
 #include <dynarmic/interface/A32/a32.h>
 #include <dynarmic/interface/A64/a64.h>
@@ -81,7 +81,7 @@ private:
 
     using JitCacheKey = std::pair<Common::PageTable*, std::size_t>;
     using JitCacheType =
-        std::unordered_map<JitCacheKey, std::shared_ptr<Dynarmic::A32::Jit>, Common::PairHash>;
+        tsl::robin_map<JitCacheKey, std::shared_ptr<Dynarmic::A32::Jit>, Common::PairHash>;
 
     friend class DynarmicCallbacks32;
     friend class DynarmicCP15;

src/core/arm/dynarmic/arm_dynarmic_64.h

@@ -5,7 +5,7 @@
 
 #include <atomic>
 #include <memory>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 
 #include <dynarmic/interface/A64/a64.h>
 #include "common/common_types.h"
@@ -73,7 +73,7 @@ private:
 
     using JitCacheKey = std::pair<Common::PageTable*, std::size_t>;
     using JitCacheType =
-        std::unordered_map<JitCacheKey, std::shared_ptr<Dynarmic::A64::Jit>, Common::PairHash>;
+        tsl::robin_map<JitCacheKey, std::shared_ptr<Dynarmic::A64::Jit>, Common::PairHash>;
 
     friend class DynarmicCallbacks64;
     std::unique_ptr<DynarmicCallbacks64> cb;

src/core/hid/emulated_console.h

@@ -8,7 +8,7 @@
 #include <memory>
 #include <mutex>
 #include <optional>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -190,7 +190,7 @@ private:
 
     mutable std::mutex mutex;
     mutable std::mutex callback_mutex;
-    std::unordered_map<int, ConsoleUpdateCallback> callback_list;
+    tsl::robin_map<int, ConsoleUpdateCallback> callback_list;
     int last_callback_key = 0;
 
     // Stores the current status of all console input

src/core/hid/emulated_controller.h

@@ -7,7 +7,7 @@
 #include <functional>
 #include <memory>
 #include <mutex>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <vector>
 
 #include "common/common_types.h"
@@ -603,7 +603,7 @@ private:
 
     mutable std::mutex mutex;
     mutable std::mutex callback_mutex;
-    std::unordered_map<int, ControllerUpdateCallback> callback_list;
+    tsl::robin_map<int, ControllerUpdateCallback> callback_list;
     int last_callback_key = 0;
 
     // Stores the current status of all controller input

src/core/hid/emulated_devices.h

@@ -7,7 +7,7 @@
 #include <functional>
 #include <memory>
 #include <mutex>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <vector>
 
 #include "common/common_types.h"
@@ -202,7 +202,7 @@ private:
 
     mutable std::mutex mutex;
     mutable std::mutex callback_mutex;
-    std::unordered_map<int, InterfaceUpdateCallback> callback_list;
+    tsl::robin_map<int, InterfaceUpdateCallback> callback_list;
     int last_callback_key = 0;
 
     // Stores the current status of all external device input

src/core/hle/kernel/kernel.cpp

@@ -7,7 +7,7 @@
 #include <functional>
 #include <memory>
 #include <thread>
-#include <unordered_set>
+#include <tsl/robin_set.h>
 #include <utility>
 
 #include "common/assert.h"
@@ -798,8 +798,8 @@ struct KernelCore::Impl {
 
     std::unique_ptr<KObjectNameGlobalData> object_name_global_data;
 
-    std::unordered_set<KAutoObject*> registered_objects;
+    tsl::robin_set<KAutoObject*> registered_objects;
-    std::unordered_set<KAutoObject*> registered_in_use_objects;
+    tsl::robin_set<KAutoObject*> registered_in_use_objects;
 
     std::mutex server_lock;
     std::vector<std::unique_ptr<Service::ServerManager>> server_managers;

src/core/hle/kernel/kernel.h

@@ -7,7 +7,7 @@
 #include <functional>
 #include <memory>
 #include <string>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <vector>
 
 #include "common/polyfill_thread.h"

src/core/hle/service/am/applets/applet_web_browser_types.h

@@ -4,7 +4,7 @@
 #pragma once
 
 #include <array>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <vector>
 
 #include "common/common_funcs.h"
@@ -172,6 +172,6 @@ struct WebCommonReturnValue {
 };
 static_assert(sizeof(WebCommonReturnValue) == 0x1010, "WebCommonReturnValue has incorrect size.");
 
-using WebArgInputTLVMap = std::unordered_map<WebArgInputTLVType, std::vector<u8>>;
+using WebArgInputTLVMap = tsl::robin_map<WebArgInputTLVType, std::vector<u8>>;
 
 } // namespace Service::AM::Applets

src/core/hle/service/ldn/lan_discovery.h

@@ -12,7 +12,7 @@
 #include <random>
 #include <span>
 #include <thread>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 
 #include "common/logging/log.h"
 #include "common/socket_types.h"
@@ -117,7 +117,7 @@ protected:
     std::array<LanStation, StationCountMax> stations;
     std::array<NodeLatestUpdate, NodeCountMax> node_changes{};
     std::array<u8, NodeCountMax> node_last_states{};
-    std::unordered_map<MacAddress, NetworkInfo, MACAddressHash> scan_results{};
+    tsl::robin_map<MacAddress, NetworkInfo, MACAddressHash> scan_results{};
     NodeInfo node_info{};
     NetworkInfo network_info{};
     State state{State::None};

src/core/hle/service/lm/lm.cpp

@@ -4,8 +4,9 @@
 #include <string>
 
 #include <optional>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <boost/container_hash/hash.hpp>
+
 #include "common/logging/log.h"
 #include "core/core.h"
 #include "core/hle/service/ipc_helpers.h"
@@ -326,7 +327,7 @@ private:
     };
     static_assert(sizeof(LogPacketHeader) == 0x18, "LogPacketHeader is an invalid size");
 
-    std::unordered_map<LogPacketHeaderEntry, std::vector<u8>> entries{};
+    tsl::robin_map<LogPacketHeaderEntry, std::vector<u8>> entries{};
     LogDestination destination{LogDestination::All};
 };
 

src/core/hle/service/nvdrv/core/container.h

@@ -6,7 +6,7 @@
 
 #include <deque>
 #include <memory>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 
 #include "core/hle/service/nvdrv/nvdata.h"
 
@@ -35,7 +35,7 @@ public:
     const SyncpointManager& GetSyncpointManager() const;
 
     struct Host1xDeviceFileData {
-        std::unordered_map<DeviceFD, u32> fd_to_id{};
+        tsl::robin_map<DeviceFD, u32> fd_to_id{};
         std::deque<u32> syncpts_accumulated{};
         u32 nvdec_next_id{};
         u32 vic_next_id{};

src/core/hle/service/nvdrv/core/nvmap.h

@@ -9,7 +9,7 @@
 #include <memory>
 #include <mutex>
 #include <optional>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <assert.h>
 
 #include "common/bit_field.h"
@@ -149,7 +149,7 @@ private:
     std::list<std::shared_ptr<Handle>> unmap_queue{};
     std::mutex unmap_queue_lock{}; //!< Protects access to `unmap_queue`
 
-    std::unordered_map<Handle::Id, std::shared_ptr<Handle>>
+    tsl::robin_map<Handle::Id, std::shared_ptr<Handle>>
         handles{};           //!< Main owning map of handles
     std::mutex handles_lock; //!< Protects access to `handles`
 

src/core/hle/service/nvdrv/devices/nvmap.h

@@ -4,8 +4,9 @@
 #pragma once
 
 #include <memory>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <vector>
+
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"

src/core/hle/service/nvdrv/nvdrv.h

@@ -9,7 +9,7 @@
 #include <memory>
 #include <span>
 #include <string>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <vector>
 
 #include "common/common_types.h"
@@ -103,7 +103,7 @@ private:
     /// Id to use for the next open file descriptor.
     DeviceFD next_fd = 1;
 
-    using FilesContainerType = std::unordered_map<DeviceFD, std::shared_ptr<Devices::nvdevice>>;
+    using FilesContainerType = tsl::robin_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;
 
-    std::unordered_map<std::string, std::function<FilesContainerType::iterator(DeviceFD)>> builders;
+    tsl::robin_map<std::string, std::function<FilesContainerType::iterator(DeviceFD)>> builders;
 };
 
 void LoopProcess(Nvnflinger::Nvnflinger& nvnflinger, Core::System& system);

src/core/hle/service/nvnflinger/hos_binder_driver_server.h

@@ -5,7 +5,7 @@
 
 #include <memory>
 #include <mutex>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 
 #include "common/common_types.h"
 #include "core/hle/service/kernel_helpers.h"
@@ -29,7 +29,7 @@ public:
 private:
     KernelHelpers::ServiceContext service_context;
 
-    std::unordered_map<u64, std::unique_ptr<android::IBinder>> producers;
+    tsl::robin_map<u64, std::unique_ptr<android::IBinder>> producers;
     std::mutex lock;
     u64 last_id{};
 };

src/core/hle/service/sm/sm.h

@@ -6,7 +6,7 @@
 #include <memory>
 #include <mutex>
 #include <string>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 
 #include "common/concepts.h"
 #include "core/hle/kernel/k_port.h"
@@ -79,8 +79,8 @@ private:
 
     /// Map of registered services, retrieved using GetServicePort.
     std::mutex lock;
-    std::unordered_map<std::string, SessionRequestHandlerPtr> registered_services;
+    tsl::robin_map<std::string, SessionRequestHandlerPtr> registered_services;
-    std::unordered_map<std::string, Kernel::KPort*> service_ports;
+    tsl::robin_map<std::string, Kernel::KPort*> service_ports;
 
     /// Kernel context
     Kernel::KernelCore& kernel;

src/input_common/drivers/sdl_driver.cpp

@@ -570,7 +570,7 @@ SDLDriver::~SDLDriver() {
 
 std::vector<Common::ParamPackage> SDLDriver::GetInputDevices() const {
     std::vector<Common::ParamPackage> devices;
-    std::unordered_map<int, std::shared_ptr<SDLJoystick>> joycon_pairs;
+    tsl::robin_map<int, std::shared_ptr<SDLJoystick>> joycon_pairs;
     for (const auto& [key, value] : joystick_map) {
         for (const auto& joystick : value) {
             if (!joystick->GetSDLJoystick()) {

src/input_common/drivers/sdl_driver.h

@@ -6,8 +6,7 @@
 #include <atomic>
 #include <mutex>
 #include <thread>
-#include <unordered_map>
+#include <tsl/robin_map.h>
-
 #include <SDL.h>
 
 #include "common/common_types.h"
@@ -121,7 +120,7 @@ private:
     Common::SPSCQueue<VibrationRequest> vibration_queue;
 
     /// Map of GUID of a list of corresponding virtual Joysticks
-    std::unordered_map<Common::UUID, std::vector<std::shared_ptr<SDLJoystick>>> joystick_map;
+    tsl::robin_map<Common::UUID, std::vector<std::shared_ptr<SDLJoystick>>> joystick_map;
     std::mutex joystick_map_mutex;
 
     bool start_thread = false;

src/input_common/input_engine.h

@@ -5,7 +5,7 @@
 
 #include <functional>
 #include <mutex>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 
 #include "common/common_types.h"
 #include "common/input.h"
@@ -262,10 +262,10 @@ protected:
 
 private:
     struct ControllerData {
-        std::unordered_map<int, bool> buttons;
+        tsl::robin_map<int, bool> buttons;
-        std::unordered_map<int, u8> hat_buttons;
+        tsl::robin_map<int, u8> hat_buttons;
-        std::unordered_map<int, float> axes;
+        tsl::robin_map<int, float> axes;
-        std::unordered_map<int, BasicMotion> motions;
+        tsl::robin_map<int, BasicMotion> motions;
         Common::Input::BatteryLevel battery{};
         Common::Input::BodyColorStatus color{};
         Common::Input::CameraStatus camera{};
@@ -293,8 +293,8 @@ private:
     bool configuring{false};
     const std::string input_engine;
     int last_callback_key = 0;
-    std::unordered_map<PadIdentifier, ControllerData> controller_list;
+    tsl::robin_map<PadIdentifier, ControllerData> controller_list;
-    std::unordered_map<int, InputIdentifier> callback_list;
+    tsl::robin_map<int, InputIdentifier> callback_list;
     MappingCallback mapping_callback;
 };
 

src/input_common/main.h

@@ -5,7 +5,7 @@
 
 #include <memory>
 #include <string>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <vector>
 
 namespace Common {
@@ -52,9 +52,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 = std::unordered_map<Settings::NativeAnalog::Values, Common::ParamPackage>;
+using AnalogMapping = tsl::robin_map<Settings::NativeAnalog::Values, Common::ParamPackage>;
-using ButtonMapping = std::unordered_map<Settings::NativeButton::Values, Common::ParamPackage>;
+using ButtonMapping = tsl::robin_map<Settings::NativeButton::Values, Common::ParamPackage>;
-using MotionMapping = std::unordered_map<Settings::NativeMotion::Values, Common::ParamPackage>;
+using MotionMapping = tsl::robin_map<Settings::NativeMotion::Values, Common::ParamPackage>;
 
 class InputSubsystem {
 public:

src/shader_recompiler/frontend/maxwell/structured_control_flow.cpp

@@ -4,7 +4,7 @@
 #include <algorithm>
 #include <memory>
 #include <string>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <utility>
 #include <vector>
 
@@ -387,7 +387,7 @@ private:
                    std::optional<Node> return_label) {
         Statement* const false_stmt{pool.Create(Identity{}, IR::Condition{false}, &root_stmt)};
         Tree& root{root_stmt.children};
-        std::unordered_map<Flow::Block*, Node> local_labels;
+        tsl::robin_map<Flow::Block*, Node> local_labels;
         local_labels.reserve(function.blocks.size());
 
         for (Flow::Block& block : function.blocks) {

src/shader_recompiler/ir_opt/ssa_rewrite_pass.cpp

@@ -16,7 +16,7 @@
 #include <deque>
 #include <map>
 #include <span>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <variant>
 #include <vector>
 
@@ -52,7 +52,7 @@ struct IndirectBranchVariable {
 
 using Variant = std::variant<IR::Reg, IR::Pred, ZeroFlagTag, SignFlagTag, CarryFlagTag,
                              OverflowFlagTag, GotoVariable, IndirectBranchVariable>;
-using ValueMap = std::unordered_map<IR::Block*, IR::Value>;
+using ValueMap = tsl::robin_map<IR::Block*, IR::Value>;
 
 struct DefTable {
     const IR::Value& Def(IR::Block* block, IR::Reg variable) {
@@ -112,7 +112,7 @@ struct DefTable {
     }
 
     std::array<ValueMap, IR::NUM_USER_PREDS> preds;
-    std::unordered_map<u32, ValueMap> goto_vars;
+    tsl::robin_map<u32, ValueMap> goto_vars;
     ValueMap indirect_branch_var;
     ValueMap zero_flag;
     ValueMap sign_flag;
@@ -295,7 +295,7 @@ private:
         return same;
     }
 
-    std::unordered_map<IR::Block*, std::map<Variant, IR::Inst*>> incomplete_phis;
+    tsl::robin_map<IR::Block*, std::map<Variant, IR::Inst*>> incomplete_phis;
     DefTable current_def;
 };
 

src/tests/common/fibers.cpp

@@ -8,7 +8,7 @@
 #include <mutex>
 #include <stdexcept>
 #include <thread>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <vector>
 
 #include <catch2/catch_test_macros.hpp>
@@ -36,7 +36,7 @@ public:
 
 private:
     mutable std::mutex mutex;
-    std::unordered_map<std::thread::id, u32> ids;
+    tsl::robin_map<std::thread::id, u32> ids;
 };
 
 class TestControl1 {

src/tests/video_core/memory_tracker.cpp

@@ -3,8 +3,7 @@
 
 #include <memory>
 #include <stdexcept>
-#include <unordered_map>
+#include <tsl/robin_map.h>
-
 #include <catch2/catch_test_macros.hpp>
 
 #include "common/alignment.h"
@@ -53,7 +52,7 @@ public:
     }
 
 private:
-    std::unordered_map<u64, int> page_table;
+    tsl::robin_map<u64, int> page_table;
 };
 } // Anonymous namespace
 

src/video_core/buffer_cache/buffer_cache_base.h

@@ -10,7 +10,7 @@
 #include <mutex>
 #include <numeric>
 #include <span>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <vector>
 
 #include <boost/container/small_vector.hpp>

src/video_core/buffer_cache/memory_tracker_base.h

@@ -8,7 +8,7 @@
 #include <deque>
 #include <limits>
 #include <type_traits>
-#include <unordered_set>
+#include <tsl/robin_set.h>
 #include <utility>
 
 #include "common/alignment.h"
@@ -291,7 +291,7 @@ private:
 
     std::array<Manager*, NUM_HIGH_PAGES> top_tier{};
 
-    std::unordered_set<u32> cached_pages;
+    tsl::robin_set<u32> cached_pages;
 
     RasterizerInterface* rasterizer = nullptr;
 };

src/video_core/control/channel_state_cache.h

@@ -7,7 +7,7 @@
 #include <limits>
 #include <mutex>
 #include <optional>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <vector>
 
 #include "common/common_types.h"
@@ -83,14 +83,14 @@ protected:
 
     std::deque<P> channel_storage;
     std::deque<size_t> free_channel_ids;
-    std::unordered_map<s32, size_t> channel_map;
+    tsl::robin_map<s32, size_t> channel_map;
     std::vector<size_t> active_channel_ids;
     struct AddresSpaceRef {
         size_t ref_count;
         size_t storage_id;
         Tegra::MemoryManager* gpu_memory;
     };
-    std::unordered_map<size_t, AddresSpaceRef> address_spaces;
+    tsl::robin_map<size_t, AddresSpaceRef> address_spaces;
     mutable std::mutex config_mutex;
 
     virtual void OnGPUASRegister([[maybe_unused]] size_t map_id) {}

src/video_core/control/scheduler.h

@@ -5,7 +5,7 @@
 
 #include <memory>
 #include <mutex>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 
 #include "video_core/dma_pusher.h"
 
@@ -27,7 +27,7 @@ public:
     void DeclareChannel(std::shared_ptr<ChannelState> new_channel);
 
 private:
-    std::unordered_map<s32, std::shared_ptr<ChannelState>> channels;
+    tsl::robin_map<s32, std::shared_ptr<ChannelState>> channels;
     std::mutex scheduling_guard;
     GPU& gpu;
 };

src/video_core/engines/maxwell_3d.h

@@ -3053,7 +3053,7 @@ public:
 
     void SetHLEReplacementAttributeType(u32 bank, u32 offset, HLEReplacementAttributeType name);
 
-    std::unordered_map<u64, HLEReplacementAttributeType> replace_table;
+    tsl::robin_map<u64, HLEReplacementAttributeType> replace_table;
 
     static_assert(sizeof(Regs) == Regs::NUM_REGS * sizeof(u32), "Maxwell3D Regs has wrong size");
     static_assert(std::is_trivially_copyable_v<Regs>, "Maxwell3D Regs must be trivially copyable");

src/video_core/engines/sw_blitter/converter.cpp

@@ -4,7 +4,7 @@
 #include <array>
 #include <cmath>
 #include <span>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 
 #include "common/assert.h"
 #include "common/bit_cast.h"
@@ -921,7 +921,7 @@ public:
 };
 
 struct ConverterFactory::ConverterFactoryImpl {
-    std::unordered_map<RenderTargetFormat, std::unique_ptr<Converter>> converters_cache;
+    tsl::robin_map<RenderTargetFormat, std::unique_ptr<Converter>> converters_cache;
 };
 
 ConverterFactory::ConverterFactory() {

src/video_core/gpu.cpp

@@ -385,7 +385,7 @@ struct GPU::Impl {
     std::unique_ptr<Core::Frontend::GraphicsContext> cpu_context;
 
     std::unique_ptr<Tegra::Control::Scheduler> scheduler;
-    std::unordered_map<s32, std::shared_ptr<Tegra::Control::ChannelState>> channels;
+    tsl::robin_map<s32, std::shared_ptr<Tegra::Control::ChannelState>> channels;
     Tegra::Control::ChannelState* current_channel;
     s32 bound_channel{-1};
 

src/video_core/macro/macro.h

@@ -5,7 +5,9 @@
 
 #include <memory>
 #include <unordered_map>
+#include <tsl/robin_map.h>
 #include <vector>
+
 #include "common/bit_field.h"
 #include "common/common_types.h"
 
@@ -134,8 +136,8 @@ private:
         bool has_hle_program{};
     };
 
-    std::unordered_map<u32, CacheInfo> macro_cache;
+    tsl::robin_map<u32, CacheInfo> macro_cache;
-    std::unordered_map<u32, std::vector<u32>> uploaded_macro_code;
+    tsl::robin_map<u32, std::vector<u32>> uploaded_macro_code;
     std::unique_ptr<HLEMacro> hle_macros;
     Engines::Maxwell3D& maxwell3d;
 };

src/video_core/macro/macro_hle.h

@@ -6,6 +6,7 @@
 #include <functional>
 #include <memory>
 #include <unordered_map>
+#include <tsl/robin_map.h>
 
 #include "common/common_types.h"
 
@@ -26,7 +27,7 @@ public:
 
 private:
     Engines::Maxwell3D& maxwell3d;
-    std::unordered_map<u64, std::function<std::unique_ptr<CachedMacro>(Engines::Maxwell3D&)>>
+    tsl::robin_map<u64, std::function<std::unique_ptr<CachedMacro>(Engines::Maxwell3D&)>>
         builders;
 };
 

src/video_core/query_cache.h

@@ -12,8 +12,8 @@
 #include <memory>
 #include <mutex>
 #include <optional>
-#include <unordered_map>
+#include <tsl/robin_map.h>
-#include <unordered_set>
+#include <tsl/robin_set.h>
 #include <vector>
 
 #include "common/assert.h"
@@ -340,7 +340,7 @@ private:
 
     mutable std::recursive_mutex mutex;
 
-    std::unordered_map<u64, std::vector<CachedQuery>> cached_queries;
+    tsl::robin_map<u64, std::vector<CachedQuery>> cached_queries;
 
     std::array<CounterStream, VideoCore::NumQueryTypes> streams;
 

src/video_core/renderer_opengl/gl_shader_cache.h

@@ -4,7 +4,7 @@
 #pragma once
 
 #include <filesystem>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 
 #include "common/common_types.h"
 #include "common/thread_worker.h"
@@ -77,8 +77,8 @@ private:
     GraphicsPipeline* current_pipeline{};
 
     ShaderContext::ShaderPools main_pools;
-    std::unordered_map<GraphicsPipelineKey, std::unique_ptr<GraphicsPipeline>> graphics_cache;
+    tsl::robin_map<GraphicsPipelineKey, std::unique_ptr<GraphicsPipeline>> graphics_cache;
-    std::unordered_map<ComputePipelineKey, std::unique_ptr<ComputePipeline>> compute_cache;
+    tsl::robin_map<ComputePipelineKey, std::unique_ptr<ComputePipeline>> compute_cache;
 
     Shader::Profile profile;
     Shader::HostTranslateInfo host_info;

src/video_core/renderer_opengl/gl_texture_cache.h

@@ -149,7 +149,7 @@ private:
     UtilShaders util_shaders;
     FormatConversionPass format_conversion_pass;
 
-    std::array<std::unordered_map<GLenum, FormatProperties>, 3> format_properties;
+    std::array<tsl::robin_map<GLenum, FormatProperties>, 3> format_properties;
     bool has_broken_texture_view_formats = false;
 
     OGLTexture null_image_1d_array;

src/video_core/renderer_vulkan/vk_pipeline_cache.h

@@ -8,7 +8,7 @@
 #include <filesystem>
 #include <memory>
 #include <type_traits>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <vector>
 
 #include "common/common_types.h"
@@ -154,8 +154,8 @@ private:
     GraphicsPipelineCacheKey graphics_key{};
     GraphicsPipeline* current_pipeline{};
 
-    std::unordered_map<ComputePipelineCacheKey, std::unique_ptr<ComputePipeline>> compute_cache;
+    tsl::robin_map<ComputePipelineCacheKey, std::unique_ptr<ComputePipeline>> compute_cache;
-    std::unordered_map<GraphicsPipelineCacheKey, std::unique_ptr<GraphicsPipeline>> graphics_cache;
+    tsl::robin_map<GraphicsPipelineCacheKey, std::unique_ptr<GraphicsPipeline>> graphics_cache;
 
     ShaderPools main_pools;
 

src/video_core/renderer_vulkan/vk_render_pass_cache.cpp

@@ -1,8 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2021 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <unordered_map>
+#include <tsl/robin_map.h>
-
 #include <boost/container/static_vector.hpp>
 
 #include "video_core/renderer_vulkan/maxwell_to_vk.h"

src/video_core/renderer_vulkan/vk_render_pass_cache.h

@@ -5,6 +5,7 @@
 
 #include <mutex>
 #include <unordered_map>
+#include <tsl/robin_map.h>
 
 #include "video_core/surface.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
@@ -47,7 +48,7 @@ public:
 
 private:
     const Device* device{};
-    std::unordered_map<RenderPassKey, vk::RenderPass> cache;
+    tsl::robin_map<RenderPassKey, vk::RenderPass> cache;
     std::mutex mutex;
 };
 

src/video_core/shader_cache.h

@@ -7,7 +7,7 @@
 #include <memory>
 #include <mutex>
 #include <span>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <utility>
 #include <vector>
 
@@ -150,8 +150,8 @@ private:
     mutable std::mutex lookup_mutex;
     std::mutex invalidation_mutex;
 
-    std::unordered_map<u64, std::unique_ptr<Entry>> lookup_cache;
+    tsl::robin_map<u64, std::unique_ptr<Entry>> lookup_cache;
-    std::unordered_map<u64, std::vector<Entry*>> invalidation_cache;
+    tsl::robin_map<u64, std::vector<Entry*>> invalidation_cache;
     std::vector<std::unique_ptr<ShaderInfo>> storage;
     std::vector<Entry*> marked_for_removal;
 };

src/video_core/shader_environment.h

@@ -11,7 +11,7 @@
 #include <optional>
 #include <span>
 #include <type_traits>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <vector>
 
 #include "common/common_types.h"
@@ -76,10 +76,10 @@ protected:
     GPUVAddr program_base{};
 
     std::vector<u64> code;
-    std::unordered_map<u32, Shader::TextureType> texture_types;
+    tsl::robin_map<u32, Shader::TextureType> texture_types;
-    std::unordered_map<u32, Shader::TexturePixelFormat> texture_pixel_formats;
+    tsl::robin_map<u32, Shader::TexturePixelFormat> texture_pixel_formats;
-    std::unordered_map<u64, u32> cbuf_values;
+    tsl::robin_map<u64, u32> cbuf_values;
-    std::unordered_map<u64, Shader::ReplaceConstant> cbuf_replacements;
+    tsl::robin_map<u64, Shader::ReplaceConstant> cbuf_replacements;
 
     u32 local_memory_size{};
     u32 texture_bound{};
@@ -192,10 +192,10 @@ public:
 
 private:
     std::vector<u64> code;
-    std::unordered_map<u32, Shader::TextureType> texture_types;
+    tsl::robin_map<u32, Shader::TextureType> texture_types;
-    std::unordered_map<u32, Shader::TexturePixelFormat> texture_pixel_formats;
+    tsl::robin_map<u32, Shader::TexturePixelFormat> texture_pixel_formats;
-    std::unordered_map<u64, u32> cbuf_values;
+    tsl::robin_map<u64, u32> cbuf_values;
-    std::unordered_map<u64, Shader::ReplaceConstant> cbuf_replacements;
+    tsl::robin_map<u64, Shader::ReplaceConstant> cbuf_replacements;
     std::array<u32, 3> workgroup_size{};
     u32 local_memory_size{};
     u32 shared_memory_size{};

src/video_core/texture_cache/texture_cache.h

@@ -3,7 +3,7 @@
 
 #pragma once
 
-#include <unordered_set>
+#include <tsl/robin_set.h>
 #include <boost/container/small_vector.hpp>
 
 #include "common/alignment.h"
@@ -1970,7 +1970,7 @@ void TextureCache<P>::UnregisterImage(ImageId image_id) {
     lru_cache.Free(image.lru_index);
     const auto& clear_page_table =
         [image_id](u64 page,
-                   std::unordered_map<u64, std::vector<ImageId>, Common::IdentityHash<u64>>&
+                   tsl::robin_map<u64, std::vector<ImageId>, Common::IdentityHash<u64>>&
                        selected_page_table) {
             const auto page_it = selected_page_table.find(page);
             if (page_it == selected_page_table.end()) {

src/video_core/texture_cache/texture_cache_base.h

@@ -9,8 +9,8 @@
 #include <mutex>
 #include <span>
 #include <type_traits>
-#include <unordered_map>
+#include <tsl/robin_map.h>
-#include <unordered_set>
+#include <tsl/robin_set.h>
 #include <vector>
 #include <boost/container/small_vector.hpp>
 #include <queue>
@@ -61,7 +61,7 @@ struct AsyncDecodeContext {
     std::atomic_bool complete;
 };
 
-using TextureCacheGPUMap = std::unordered_map<u64, std::vector<ImageId>, Common::IdentityHash<u64>>;
+using TextureCacheGPUMap = tsl::robin_map<u64, std::vector<ImageId>, Common::IdentityHash<u64>>;
 
 class TextureCacheChannelInfo : public ChannelInfo {
 public:
@@ -80,8 +80,8 @@ public:
     std::vector<SamplerId> compute_sampler_ids;
     std::vector<ImageViewId> compute_image_view_ids;
 
-    std::unordered_map<TICEntry, ImageViewId> image_views;
+    tsl::robin_map<TICEntry, ImageViewId> image_views;
-    std::unordered_map<TSCEntry, SamplerId> samplers;
+    tsl::robin_map<TSCEntry, SamplerId> samplers;
 
     TextureCacheGPUMap* gpu_page_table;
 };
@@ -425,11 +425,11 @@ private:
 
     RenderTargets render_targets;
 
-    std::unordered_map<RenderTargets, FramebufferId> framebuffers;
+    tsl::robin_map<RenderTargets, FramebufferId> framebuffers;
 
-    std::unordered_map<u64, std::vector<ImageMapId>, Common::IdentityHash<u64>> page_table;
+    tsl::robin_map<u64, std::vector<ImageMapId>, Common::IdentityHash<u64>> page_table;
-    std::unordered_map<u64, std::vector<ImageId>, Common::IdentityHash<u64>> sparse_page_table;
+    tsl::robin_map<u64, std::vector<ImageId>, Common::IdentityHash<u64>> sparse_page_table;
-    std::unordered_map<ImageId, boost::container::small_vector<ImageViewId, 16>> sparse_views;
+    tsl::robin_map<ImageId, boost::container::small_vector<ImageViewId, 16>> sparse_views;
 
     VAddr virtual_invalid_space{};
 
@@ -478,7 +478,7 @@ private:
     DelayedDestructionRing<ImageView, TICKS_TO_DESTROY> sentenced_image_view;
     DelayedDestructionRing<Framebuffer, TICKS_TO_DESTROY> sentenced_framebuffers;
 
-    std::unordered_map<GPUVAddr, ImageAllocId> image_allocs_table;
+    tsl::robin_map<GPUVAddr, ImageAllocId> image_allocs_table;
 
     Common::ScratchBuffer<u8> swizzle_data_buffer;
     Common::ScratchBuffer<u8> unswizzle_data_buffer;
@@ -491,17 +491,17 @@ private:
 
     // Join caching
     boost::container::small_vector<ImageId, 4> join_overlap_ids;
-    std::unordered_set<ImageId> join_overlaps_found;
+    tsl::robin_set<ImageId> join_overlaps_found;
     boost::container::small_vector<ImageId, 4> join_left_aliased_ids;
     boost::container::small_vector<ImageId, 4> join_right_aliased_ids;
-    std::unordered_set<ImageId> join_ignore_textures;
+    tsl::robin_set<ImageId> join_ignore_textures;
     boost::container::small_vector<ImageId, 4> join_bad_overlap_ids;
     struct JoinCopy {
         bool is_alias;
         ImageId id;
     };
     boost::container::small_vector<JoinCopy, 4> join_copies_to_do;
-    std::unordered_map<ImageId, size_t> join_alias_indices;
+    tsl::robin_map<ImageId, size_t> join_alias_indices;
 };
 
 } // namespace VideoCommon

src/video_core/vulkan_common/vulkan_device.cpp

@@ -6,7 +6,7 @@
 #include <chrono>
 #include <optional>
 #include <thread>
-#include <unordered_set>
+#include <tsl/robin_set.h>
 #include <utility>
 #include <vector>
 
@@ -128,7 +128,7 @@ VkFormatFeatureFlags GetFormatFeatures(VkFormatProperties properties, FormatType
     }
 }
 
-std::unordered_map<VkFormat, VkFormatProperties> GetFormatProperties(vk::PhysicalDevice physical) {
+tsl::robin_map<VkFormat, VkFormatProperties> GetFormatProperties(vk::PhysicalDevice physical) {
     static constexpr std::array formats{
         VK_FORMAT_A1R5G5B5_UNORM_PACK16,
         VK_FORMAT_A2B10G10R10_SINT_PACK32,
@@ -268,7 +268,7 @@ std::unordered_map<VkFormat, VkFormatProperties> GetFormatProperties(vk::Physica
         VK_FORMAT_R8_USCALED,
         VK_FORMAT_S8_UINT,
     };
-    std::unordered_map<VkFormat, VkFormatProperties> format_properties;
+    tsl::robin_map<VkFormat, VkFormatProperties> format_properties;
     for (const auto format : formats) {
         format_properties.emplace(format, physical.GetFormatProperties(format));
     }
@@ -276,7 +276,7 @@ std::unordered_map<VkFormat, VkFormatProperties> GetFormatProperties(vk::Physica
 }
 
 #if defined(ANDROID) && defined(ARCHITECTURE_arm64)
-void OverrideBcnFormats(std::unordered_map<VkFormat, VkFormatProperties>& format_properties) {
+void OverrideBcnFormats(tsl::robin_map<VkFormat, VkFormatProperties>& format_properties) {
     // These properties are extracted from Adreno driver 512.687.0
     constexpr VkFormatFeatureFlags tiling_features{
         VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT | VK_FORMAT_FEATURE_BLIT_SRC_BIT |
@@ -1262,7 +1262,7 @@ void Device::CollectToolingInfo() {
 std::vector<VkDeviceQueueCreateInfo> Device::GetDeviceQueueCreateInfos() const {
     static constexpr float QUEUE_PRIORITY = 1.0f;
 
-    std::unordered_set<u32> unique_queue_families{graphics_family, present_family};
+    tsl::robin_set<u32> unique_queue_families{graphics_family, present_family};
     std::vector<VkDeviceQueueCreateInfo> queue_cis;
     queue_cis.reserve(unique_queue_families.size());
 

src/video_core/vulkan_common/vulkan_device.h

@@ -6,9 +6,8 @@
 #include <set>
 #include <span>
 #include <string>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <vector>
-
 #include "common/common_types.h"
 #include "common/logging/log.h"
 #include "common/settings.h"
@@ -756,7 +755,7 @@ private:
     std::vector<size_t> valid_heap_memory;                   ///< Heaps used.
 
     /// Format properties dictionary.
-    std::unordered_map<VkFormat, VkFormatProperties> format_properties;
+    tsl::robin_map<VkFormat, VkFormatProperties> format_properties;
 
     /// Nsight Aftermath GPU crash tracker
     std::unique_ptr<NsightAftermathTracker> nsight_aftermath_tracker;

src/yuzu/compatibility_list.h

@@ -4,13 +4,12 @@
 #pragma once
 
 #include <string>
-#include <unordered_map>
+#include <tsl/robin_map.h>
-
 #include <QString>
 
 #include "common/common_types.h"
 
-using CompatibilityList = std::unordered_map<std::string, std::pair<QString, QString>>;
+using CompatibilityList = tsl::robin_map<std::string, std::pair<QString, QString>>;
 
 CompatibilityList::const_iterator FindMatchingCompatibilityEntry(
     const CompatibilityList& compatibility_list, u64 program_id);

src/yuzu/configuration/input_profiles.h

@@ -4,7 +4,7 @@
 #pragma once
 
 #include <string>
-#include <unordered_map>
+#include <tsl/robin_map.h>
 
 namespace Core {
 class System;
@@ -30,5 +30,5 @@ public:
 private:
     bool ProfileExistsInMap(const std::string& profile_name) const;
 
-    std::unordered_map<std::string, std::unique_ptr<Config>> map_profiles;
+    tsl::robin_map<std::string, std::unique_ptr<Config>> map_profiles;
 };

src/yuzu/loading_screen.cpp

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <unordered_map>
+#include <tsl/robin_map.h>
 #include <QBuffer>
 #include <QByteArray>
 #include <QGraphicsOpacityEffect>

src/yuzu/loading_screen.h

@@ -77,8 +77,8 @@ private:
     std::unique_ptr<QPropertyAnimation> fadeout_animation;
 
     // Definitions for the differences in text and styling for each stage
-    std::unordered_map<VideoCore::LoadCallbackStage, const char*> progressbar_style;
+    tsl::robin_map<VideoCore::LoadCallbackStage, const char*> progressbar_style;
-    std::unordered_map<VideoCore::LoadCallbackStage, QString> stage_translations;
+    tsl::robin_map<VideoCore::LoadCallbackStage, QString> stage_translations;
 
     // newly generated shaders are added to the end of the file, so when loading and compiling
     // shaders, it will start quickly but end slow if new shaders were added since previous launch.

src/yuzu/multiplayer/chat_room.h

@@ -4,8 +4,8 @@
 #pragma once
 
 #include <memory>
-#include <unordered_map>
+#include <tsl/robin_map.h>
-#include <unordered_set>
+#include <tsl/robin_set.h>
 #include <QDialog>
 #include <QSortFilterProxyModel>
 #include <QStandardItemModel>
@@ -64,8 +64,8 @@ private:
     bool has_mod_perms = false;
     QStandardItemModel* player_list;
     std::unique_ptr<Ui::ChatRoom> ui;
-    std::unordered_set<std::string> block_list;
+    tsl::robin_set<std::string> block_list;
-    std::unordered_map<std::string, QPixmap> icon_cache;
+    tsl::robin_map<std::string, QPixmap> icon_cache;
     Network::RoomNetwork* room_network;
 };