mirrors/yuzu
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Robin map and robin set implemented

Browse source 
Robin map and robin set implemented, like Skyline, for more performance.
This commit is contained in:
Franco 2023-09-17 21:36:38 -03:00
parent bbfd9eb428
commit 249c3c1015
57 changed files with 152 additions and 143 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
.gitmodules vendored
View file

@ -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

3
externals/CMakeLists.txt vendored
View file

@ -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)

2
src/android/app/src/main/jni/native.cpp
View file

@ -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;

4
src/common/fs/path_util.cpp
View file

@ -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) {

5
src/common/host_memory.cpp
View file

@ -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

5
src/common/input.h
View file

@ -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 {

4
src/common/param_package.h
View file

@ -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);

4
src/core/arm/dynarmic/arm_dynarmic_32.h
View file

@ -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;

4
src/core/arm/dynarmic/arm_dynarmic_64.h
View file

@ -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;

4
src/core/hid/emulated_console.h
View file

@ -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

4
src/core/hid/emulated_controller.h
View file

@ -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

4
src/core/hid/emulated_devices.h
View file

@ -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

6
src/core/hle/kernel/kernel.cpp
View file

@ -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;
std::unordered_set<KAutoObject*> registered_in_use_objects;
tsl::robin_set<KAutoObject*> registered_objects;
tsl::robin_set<KAutoObject*> registered_in_use_objects;
std::mutex server_lock;
std::vector<std::unique_ptr<Service::ServerManager>> server_managers;

2
src/core/hle/kernel/kernel.h
View file

@ -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"

4
src/core/hle/service/am/applets/applet_web_browser_types.h
View file

@ -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

4
src/core/hle/service/ldn/lan_discovery.h
View file

@ -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};

5
src/core/hle/service/lm/lm.cpp
View file

@ -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};
};

4
src/core/hle/service/nvdrv/core/container.h
View file

@ -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{};

4
src/core/hle/service/nvdrv/core/nvmap.h
View file

@ -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`

3
src/core/hle/service/nvdrv/devices/nvmap.h
View file

@ -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"

6
src/core/hle/service/nvdrv/nvdrv.h
View file

@ -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);

4
src/core/hle/service/nvnflinger/hos_binder_driver_server.h
View file

@ -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{};
};

6
src/core/hle/service/sm/sm.h
View file

@ -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;
std::unordered_map<std::string, Kernel::KPort*> service_ports;
tsl::robin_map<std::string, SessionRequestHandlerPtr> registered_services;
tsl::robin_map<std::string, Kernel::KPort*> service_ports;
/// Kernel context
Kernel::KernelCore& kernel;

2
src/input_common/drivers/sdl_driver.cpp
View file

@ -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()) {

5
src/input_common/drivers/sdl_driver.h
View file

@ -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;

14
src/input_common/input_engine.h
View file

@ -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;
std::unordered_map<int, u8> hat_buttons;
std::unordered_map<int, float> axes;
std::unordered_map<int, BasicMotion> motions;
tsl::robin_map<int, bool> buttons;
tsl::robin_map<int, u8> hat_buttons;
tsl::robin_map<int, float> axes;
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;
std::unordered_map<int, InputIdentifier> callback_list;
tsl::robin_map<PadIdentifier, ControllerData> controller_list;
tsl::robin_map<int, InputIdentifier> callback_list;
MappingCallback mapping_callback;
};

8
src/input_common/main.h
View file

@ -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 ButtonMapping = std::unordered_map<Settings::NativeButton::Values, Common::ParamPackage>;
using MotionMapping = std::unordered_map<Settings::NativeMotion::Values, Common::ParamPackage>;
using AnalogMapping = tsl::robin_map<Settings::NativeAnalog::Values, Common::ParamPackage>;
using ButtonMapping = tsl::robin_map<Settings::NativeButton::Values, Common::ParamPackage>;
using MotionMapping = tsl::robin_map<Settings::NativeMotion::Values, Common::ParamPackage>;
class InputSubsystem {
public:

4
src/shader_recompiler/frontend/maxwell/structured_control_flow.cpp
View file

@ -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) {

8
src/shader_recompiler/ir_opt/ssa_rewrite_pass.cpp
View file

@ -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;
};

4
src/tests/common/fibers.cpp
View file

@ -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 {

5
src/tests/video_core/memory_tracker.cpp
View file

@ -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

2
src/video_core/buffer_cache/buffer_cache_base.h
View file

@ -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>

4
src/video_core/buffer_cache/memory_tracker_base.h
View file

@ -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;
};

6
src/video_core/control/channel_state_cache.h
View file

@ -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) {}

4
src/video_core/control/scheduler.h
View file

@ -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;
};

2
src/video_core/engines/maxwell_3d.h
View file

@ -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");

4
src/video_core/engines/sw_blitter/converter.cpp
View file

@ -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() {

2
src/video_core/gpu.cpp
View file

@ -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};

6
src/video_core/macro/macro.h
View file

@ -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;
std::unordered_map<u32, std::vector<u32>> uploaded_macro_code;
tsl::robin_map<u32, CacheInfo> macro_cache;
tsl::robin_map<u32, std::vector<u32>> uploaded_macro_code;
std::unique_ptr<HLEMacro> hle_macros;
Engines::Maxwell3D& maxwell3d;
};

3
src/video_core/macro/macro_hle.h
View file

@ -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;
};

6
src/video_core/query_cache.h
View file

@ -12,8 +12,8 @@
#include <memory>
#include <mutex>
#include <optional>
#include <unordered_map>
#include <unordered_set>
#include <tsl/robin_map.h>
#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;

6
src/video_core/renderer_opengl/gl_shader_cache.h
View file

@ -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;
std::unordered_map<ComputePipelineKey, std::unique_ptr<ComputePipeline>> compute_cache;
tsl::robin_map<GraphicsPipelineKey, std::unique_ptr<GraphicsPipeline>> graphics_cache;
tsl::robin_map<ComputePipelineKey, std::unique_ptr<ComputePipeline>> compute_cache;
Shader::Profile profile;
Shader::HostTranslateInfo host_info;

2
src/video_core/renderer_opengl/gl_texture_cache.h
View file

@ -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;

6
src/video_core/renderer_vulkan/vk_pipeline_cache.h
View file

@ -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;
std::unordered_map<GraphicsPipelineCacheKey, std::unique_ptr<GraphicsPipeline>> graphics_cache;
tsl::robin_map<ComputePipelineCacheKey, std::unique_ptr<ComputePipeline>> compute_cache;
tsl::robin_map<GraphicsPipelineCacheKey, std::unique_ptr<GraphicsPipeline>> graphics_cache;
ShaderPools main_pools;

3
src/video_core/renderer_vulkan/vk_render_pass_cache.cpp
View file

@ -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"

3
src/video_core/renderer_vulkan/vk_render_pass_cache.h
View file

@ -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;
};

6
src/video_core/shader_cache.h
View file

@ -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;
std::unordered_map<u64, std::vector<Entry*>> invalidation_cache;
tsl::robin_map<u64, std::unique_ptr<Entry>> lookup_cache;
tsl::robin_map<u64, std::vector<Entry*>> invalidation_cache;
std::vector<std::unique_ptr<ShaderInfo>> storage;
std::vector<Entry*> marked_for_removal;
};

18
src/video_core/shader_environment.h
View file

@ -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;
std::unordered_map<u32, Shader::TexturePixelFormat> texture_pixel_formats;
std::unordered_map<u64, u32> cbuf_values;
std::unordered_map<u64, Shader::ReplaceConstant> cbuf_replacements;
tsl::robin_map<u32, Shader::TextureType> texture_types;
tsl::robin_map<u32, Shader::TexturePixelFormat> texture_pixel_formats;
tsl::robin_map<u64, u32> cbuf_values;
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;
std::unordered_map<u32, Shader::TexturePixelFormat> texture_pixel_formats;
std::unordered_map<u64, u32> cbuf_values;
std::unordered_map<u64, Shader::ReplaceConstant> cbuf_replacements;
tsl::robin_map<u32, Shader::TextureType> texture_types;
tsl::robin_map<u32, Shader::TexturePixelFormat> texture_pixel_formats;
tsl::robin_map<u64, u32> cbuf_values;
tsl::robin_map<u64, Shader::ReplaceConstant> cbuf_replacements;
std::array<u32, 3> workgroup_size{};
u32 local_memory_size{};
u32 shared_memory_size{};

4
src/video_core/texture_cache/texture_cache.h
View file

@ -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()) {

26
src/video_core/texture_cache/texture_cache_base.h
View file

@ -9,8 +9,8 @@
#include <mutex>
#include <span>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <tsl/robin_map.h>
#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;
std::unordered_map<TSCEntry, SamplerId> samplers;
tsl::robin_map<TICEntry, ImageViewId> image_views;
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;
std::unordered_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<u64, std::vector<ImageMapId>, Common::IdentityHash<u64>> page_table;
tsl::robin_map<u64, std::vector<ImageId>, Common::IdentityHash<u64>> sparse_page_table;
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

10
src/video_core/vulkan_common/vulkan_device.cpp
View file

@ -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());

5
src/video_core/vulkan_common/vulkan_device.h
View file

@ -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;

5
src/yuzu/compatibility_list.h
View file

@ -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);

4
src/yuzu/configuration/input_profiles.h
View file

@ -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;
};

2
src/yuzu/loading_screen.cpp
View file

@ -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>

4
src/yuzu/loading_screen.h
View file

@ -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;
std::unordered_map<VideoCore::LoadCallbackStage, QString> stage_translations;
tsl::robin_map<VideoCore::LoadCallbackStage, const char*> progressbar_style;
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.

8
src/yuzu/multiplayer/chat_room.h
View file

@ -4,8 +4,8 @@
#pragma once
#include <memory>
#include <unordered_map>
#include <unordered_set>
#include <tsl/robin_map.h>
#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;
std::unordered_map<std::string, QPixmap> icon_cache;
tsl::robin_set<std::string> block_list;
tsl::robin_map<std::string, QPixmap> icon_cache;
Network::RoomNetwork* room_network;
};