ah yes how to forget the time i messed up a merge

Signed-off-by: lizzie <lizzie@eden-emu.dev>

src/common/logging.cpp

@@ -38,10 +38,12 @@
 #include "common/bounded_threadsafe_queue.h"
 
 namespace Common::Log {
+namespace {
 
 /// @brief A log entry. Log entries are store in a structured format to permit more varied output
 /// formatting on different frontends, as well as facilitating filtering and aggregation.
 struct Entry {
+    std::string_view thread_name;
     char const* message = nullptr;
     size_t message_len = 0;
     std::chrono::microseconds timestamp;
@@ -49,11 +51,9 @@ struct Entry {
     Level log_level{};
     const char* filename = nullptr;
     const char* function = nullptr;
-    uint32_t line_num = 0;
+    unsigned int line_num = 0;
 };
 
-namespace {
-
 /// @brief Returns the name of the passed log class as a C-string. Subclasses are separated by periods
 /// instead of underscores as in the enumeration.
 /// @note GetClassName is a macro defined by Windows.h, grrr...
@@ -90,7 +90,7 @@ std::string FormatLogMessage(const Entry& entry) noexcept {
     auto const time_fractional = uint32_t(entry.timestamp.count() % 1000000);
     auto const class_name = GetLogClassName(entry.log_class);
     auto const level_name = GetLevelName(entry.log_level);
-    return fmt::format("[{:4d}.{:06d}] {} <{}> {}:{}:{}: {}\n", time_seconds, time_fractional, class_name, level_name, entry.filename, entry.line_num, entry.function, entry.message);
+    return fmt::format("[{:4d}.{:06d}] {} <{}> ({}) {}:{}:{}: {}\n", time_seconds, time_fractional, class_name, level_name, entry.thread_name.data(), entry.filename, entry.line_num, entry.function, entry.message);
 }
 
 template <typename It>
@@ -156,7 +156,7 @@ struct Backend {
 };
 
 /// @brief Formatting specifier (to use with printf) of the equivalent fmt::format() expression
-#define CCB_PRINTF_FMT "[%4d.%06d] %s <%s> %s:%u:%s: %s"
+#define CCB_PRINTF_FMT "[%4d.%06d] %s <%s> (eden:%s) %s:%u:%s: %s"
 
 /// @brief Instead of using fmt::format() just use the system's formatting capabilities directly
 struct DirectFormatArgs {
@@ -199,7 +199,7 @@ struct ColorConsoleBackend final : public Backend {
             }());
             SetConsoleTextAttribute(console_handle, color);
             auto const df = GetDirectFormatArgs(entry);
-            std::fprintf(stdout, CCB_PRINTF_FMT "\n", df.time_seconds, df.time_fractional, df.class_name, df.level_name, entry.filename, entry.line_num, entry.function, entry.message);
+            std::fprintf(stdout, CCB_PRINTF_FMT "\n", df.time_seconds, df.time_fractional, df.class_name, df.level_name, entry.thread_name.data(), entry.filename, entry.line_num, entry.function, entry.message);
         }
     }
     void Flush() noexcept override {}
@@ -225,7 +225,7 @@ struct ColorConsoleBackend final : public Backend {
             // more restrictive, because take for example this simple prelude:
             // [  50.872256] Config <Info> common/settings.cpp:142:LogSettings:
             char buffer[256];
-            auto result = fmt::format_to_n(buffer, sizeof(buffer) - 1, "\x1b{}[{:4d}.{:06d}] {} <{}> {}:{}:{}: ", color_str, df.time_seconds, df.time_fractional, df.class_name, df.level_name, entry.filename, entry.line_num, entry.function, entry.message);
+            auto result = fmt::format_to_n(buffer, sizeof(buffer) - 1, "\x1b{}[{:4d}.{:06d}] {} <{}> {}:{}:{}: ", color_str, df.time_seconds, df.time_fractional, df.class_name, df.level_name, entry.thread_name.data(), entry.filename, entry.line_num, entry.function, entry.message);
             std::fwrite(buffer, 1, (std::min)(sizeof(buffer) - 1, result.size), stdout);
             std::fwrite(entry.message, 1, entry.message_len, stdout);
             std::fwrite("\x1b[0m\n", 1, sizeof("\x1b[0m\n"), stdout);
@@ -329,7 +329,7 @@ struct LogcatBackend : public Backend {
             }
         }();
         auto const df = GetDirectFormatArgs(entry);
-        __android_log_print(android_log_priority, "YuzuNative", CCB_PRINTF_FMT, df.time_seconds, df.time_fractional, df.class_name, df.level_name, entry.filename, entry.line_num, entry.function, entry.message);
+        __android_log_print(android_log_priority, "YuzuNative", CCB_PRINTF_FMT, df.time_seconds, df.time_fractional, df.class_name, df.level_name, entry.thread_name.data(), entry.filename, entry.line_num, entry.function, entry.message);
     }
     void Flush() noexcept override {}
 };
@@ -431,6 +431,7 @@ void FmtLogMessageImpl(Class log_class, Level log_level, const char* filename, u
         buffer[(std::min)(result.size, sizeof(buffer) - 1)] = '\0';
         logging_instance->ForEachBackend([=](Backend& backend) {
             backend.Write(Entry{
+                .thread_name = Common::GetCurrentThreadName(),
                 .message = buffer,
                 .message_len = (std::min)(result.size, sizeof(buffer) - 1),
                 .timestamp = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now() - logging_instance->time_origin),

src/common/thread.cpp

@@ -449,6 +449,13 @@ void RememberCurrentThreadNice(pid_t tid, s32 nice_value) {
 
 namespace Common {
 
+// The use of TLS is justified as it is faster than using pthread_* functions
+// and generally will be better long term... yeah %fs/%gs reloads aren't great
+// but it's better than doing a potential call-stack-fuckery...
+thread_local struct {
+    std::string name{};
+} per_thread_data = {};
+
 void SetCurrentThreadPriority(ThreadPriority new_priority) {
 #ifdef _WIN32
     int windows_priority = [&]() {
@@ -503,7 +510,7 @@ void SetCurrentThreadPriority(ThreadPriority new_priority) {
 #endif
 }
 
-void SetCurrentThreadName(const char* name) {
+void SetCurrentThreadName(const char* name) noexcept {
 #ifdef _MSC_VER
     // Sets the debugger-visible name of the current thread.
     if (auto pf = (decltype(&SetThreadDescription))(void*)GetProcAddress(GetModuleHandle(TEXT("KernelBase.dll")), "SetThreadDescription"); pf)
@@ -537,6 +544,11 @@ void SetCurrentThreadName(const char* name) {
 #else
     pthread_setname_np(pthread_self(), name);
 #endif
+    per_thread_data.name = std::string{name};
+}
+
+std::string_view GetCurrentThreadName() noexcept {
+    return per_thread_data.name;
 }
 
 void SetCurrentThreadToPerformanceCores() {

src/common/thread.h

@@ -106,7 +106,10 @@ enum class ThreadPlacement : u32 {
 };
 
 void SetCurrentThreadPriority(ThreadPriority new_priority);
-void SetCurrentThreadName(const char* name);
+
+void SetCurrentThreadName(const char* name) noexcept;
+std::string_view GetCurrentThreadName() noexcept;
+
 void SetCurrentThreadToPerformanceCores();
 void SetCurrentThreadToEfficiencyCores();
 void SetCurrentThreadToBackgroundWork();

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

@@ -25,33 +25,42 @@ NvMap::Handle::Handle(u64 size_, Id id_)
     flags.raw = 0;
 }
 
-NvResult NvMap::Handle::Alloc(Flags pFlags, u32 pAlign, u8 pKind, u64 pAddress, NvCore::SessionId pSessionId) {
+NvResult NvMap::Handle::Alloc(Flags pFlags, u32 pAlign, u8 pKind, u64 pAddress,
+                              NvCore::SessionId pSessionId) {
+    std::scoped_lock lock(mutex);
     // Handles cannot be allocated twice
     if (allocated) {
         return NvResult::AccessDenied;
     }
+
     flags = pFlags;
     kind = pKind;
     align = pAlign < YUZU_PAGESIZE ? YUZU_PAGESIZE : pAlign;
     session_id = pSessionId;
+
     // This flag is only applicable for handles with an address passed
     if (pAddress) {
         flags.keep_uncached_after_free.Assign(0);
     } else {
-        LOG_CRITICAL(Service_NVDRV, "Mapping nvmap handles without a CPU side address is unimplemented!");
+        LOG_CRITICAL(Service_NVDRV,
+                     "Mapping nvmap handles without a CPU side address is unimplemented!");
     }
+
     size = Common::AlignUp(size, YUZU_PAGESIZE);
     aligned_size = Common::AlignUp(size, align);
     address = pAddress;
     allocated = true;
+
     return NvResult::Success;
 }
 
 NvResult NvMap::Handle::Duplicate(bool internal_session) {
+    std::scoped_lock lock(mutex);
     // Unallocated handles cannot be duplicated as duplication requires memory accounting (in HOS)
     if (!allocated) [[unlikely]] {
         return NvResult::BadValue;
     }
+
     // If we internally use FromId the duplication tracking of handles won't work accurately due to
     // us not implementing per-process handle refs.
     if (internal_session) {
@@ -59,14 +68,16 @@ NvResult NvMap::Handle::Duplicate(bool internal_session) {
     } else {
         dupes++;
     }
+
     return NvResult::Success;
 }
 
 NvMap::NvMap(Container& core_, Tegra::Host1x::Host1x& host1x_) : host1x{host1x_}, core{core_} {}
 
-void NvMap::AddHandle(Handle&& handle_description) {
-    std::scoped_lock l(handles_lock);
-    handles.insert_or_assign(handle_description.id, std::move(handle_description));
+void NvMap::AddHandle(std::shared_ptr<Handle> handle_description) {
+    std::scoped_lock lock(handles_lock);
+
+    handles.emplace(handle_description->id, std::move(handle_description));
 }
 
 void NvMap::UnmapHandle(Handle& handle_description) {
@@ -105,48 +116,57 @@ void NvMap::UnmapHandle(Handle& handle_description) {
 bool NvMap::TryRemoveHandle(const Handle& handle_description) {
     // No dupes left, we can remove from handle map
     if (handle_description.dupes == 0 && handle_description.internal_dupes == 0) {
-        std::scoped_lock l(handles_lock);
-        auto it = handles.find(handle_description.id);
+        std::scoped_lock lock(handles_lock);
+
+        auto it{handles.find(handle_description.id)};
         if (it != handles.end()) {
             handles.erase(it);
         }
+
         return true;
     } else {
         return false;
     }
 }
 
-NvResult NvMap::CreateHandle(u64 size, Handle::Id& out_handle) {
-    if (!Common::AlignUp(size, YUZU_PAGESIZE)) {
+NvResult NvMap::CreateHandle(u64 size, std::shared_ptr<NvMap::Handle>& result_out) {
+    if (!size) [[unlikely]] {
         return NvResult::BadValue;
     }
-    u32 id = next_handle_id.fetch_add(HandleIdIncrement, std::memory_order_relaxed);
-    AddHandle(Handle(size, id));
-    out_handle = id;
+
+    u32 id{next_handle_id.fetch_add(HandleIdIncrement, std::memory_order_relaxed)};
+    auto handle_description{std::make_shared<Handle>(size, id)};
+    AddHandle(handle_description);
+
+    result_out = handle_description;
     return NvResult::Success;
 }
 
-std::optional<std::reference_wrapper<NvMap::Handle>> NvMap::GetHandle(Handle::Id handle) {
-    if (auto const it = handles.find(handle); it != handles.end())
-        return {it->second};
-    return std::nullopt;
+std::shared_ptr<NvMap::Handle> NvMap::GetHandle(Handle::Id handle) {
+    std::scoped_lock lock(handles_lock);
+    try {
+        return handles.at(handle);
+    } catch (std::out_of_range&) {
+        return nullptr;
+    }
 }
 
 DAddr NvMap::GetHandleAddress(Handle::Id handle) {
-    if (auto const it = handles.find(handle); it != handles.end())
-        return it->second.d_address;
-    return 0;
+    std::scoped_lock lock(handles_lock);
+    try {
+        return handles.at(handle)->d_address;
+    } catch (std::out_of_range&) {
+        return 0;
+    }
 }
 
 DAddr NvMap::PinHandle(NvMap::Handle::Id handle, bool low_area_pin) {
-    std::scoped_lock lock(handles_lock);
-    auto o = GetHandle(handle);
-    if (!o) [[unlikely]] {
+    auto handle_description{GetHandle(handle)};
+    if (!handle_description) [[unlikely]] {
         return 0;
     }
 
-    auto handle_description = &o->get();
-
+    std::scoped_lock lock(handle_description->mutex);
     const auto map_low_area = [&] {
         if (handle_description->pin_virt_address == 0) {
             u32 address = host1x.Allocator().Allocate(u32(handle_description->aligned_size));
@@ -160,15 +180,17 @@ DAddr NvMap::PinHandle(NvMap::Handle::Id handle, bool low_area_pin) {
         {
             // Lock now to prevent our queue entry from being removed for allocation in-between the
             // following check and erase
-            std::scoped_lock ql(unmap_queue_lock);
+            std::scoped_lock queueLock(unmap_queue_lock);
             if (handle_description->unmap_queue_entry) {
                 unmap_queue.erase(*handle_description->unmap_queue_entry);
                 handle_description->unmap_queue_entry.reset();
+
                 if (low_area_pin) {
                     map_low_area();
                     handle_description->pins++;
-                    return DAddr(handle_description->pin_virt_address);
+                    return static_cast<DAddr>(handle_description->pin_virt_address);
                 }
+
                 handle_description->pins++;
                 return handle_description->d_address;
             }
@@ -189,11 +211,12 @@ DAddr NvMap::PinHandle(NvMap::Handle::Id handle, bool low_area_pin) {
             while ((address = smmu.Allocate(aligned_up)) == 0) {
                 // Free handles until the allocation succeeds
                 std::scoped_lock queueLock(unmap_queue_lock);
-                if (auto free_handle = handles.find(unmap_queue.front()); free_handle != handles.end()) {
+                if (auto freeHandleDesc{unmap_queue.front()}) {
                     // Handles in the unmap queue are guaranteed not to be pinned so don't bother
                     // checking if they are before unmapping
+                    std::scoped_lock freeLock(freeHandleDesc->mutex);
                     if (handle_description->d_address)
-                        UnmapHandle(free_handle->second);
+                        UnmapHandle(*freeHandleDesc);
                 } else {
                     LOG_CRITICAL(Service_NVDRV, "Ran out of SMMU address space!");
                 }
@@ -211,44 +234,51 @@ DAddr NvMap::PinHandle(NvMap::Handle::Id handle, bool low_area_pin) {
 
     handle_description->pins++;
     if (low_area_pin) {
-        return DAddr(handle_description->pin_virt_address);
+        return static_cast<DAddr>(handle_description->pin_virt_address);
     }
     return handle_description->d_address;
 }
 
 void NvMap::UnpinHandle(Handle::Id handle) {
-    std::scoped_lock lock(handles_lock);
-    if (auto o = GetHandle(handle); o) {
-        auto handle_description = &o->get();
-        if (--handle_description->pins < 0) {
-            LOG_WARNING(Service_NVDRV, "Pin count imbalance detected!");
-        } else if (!handle_description->pins) {
-            std::scoped_lock ql(unmap_queue_lock);
-            // Add to the unmap queue allowing this handle's memory to be freed if needed
-            unmap_queue.push_back(handle);
-            handle_description->unmap_queue_entry = std::prev(unmap_queue.end());
-        }
+    auto handle_description{GetHandle(handle)};
+    if (!handle_description) {
+        return;
+    }
+
+    std::scoped_lock lock(handle_description->mutex);
+    if (--handle_description->pins < 0) {
+        LOG_WARNING(Service_NVDRV, "Pin count imbalance detected!");
+    } else if (!handle_description->pins) {
+        std::scoped_lock queueLock(unmap_queue_lock);
+
+        // Add to the unmap queue allowing this handle's memory to be freed if needed
+        unmap_queue.push_back(handle_description);
+        handle_description->unmap_queue_entry = std::prev(unmap_queue.end());
     }
 }
 
 void NvMap::DuplicateHandle(Handle::Id handle, bool internal_session) {
-    std::scoped_lock lock(handles_lock);
-    auto o = GetHandle(handle);
-    if (!o) {
+    auto handle_description{GetHandle(handle)};
+    if (!handle_description) {
         LOG_CRITICAL(Service_NVDRV, "Unregistered handle!");
         return;
     }
-    auto result = o->get().Duplicate(internal_session);
+
+    auto result = handle_description->Duplicate(internal_session);
     if (result != NvResult::Success) {
         LOG_CRITICAL(Service_NVDRV, "Could not duplicate handle!");
     }
 }
 
 std::optional<NvMap::FreeInfo> NvMap::FreeHandle(Handle::Id handle, bool internal_session) {
-    // We use a weak ptr here so we can tell when the handle has been freed and report that back to guest
-    std::scoped_lock lock(handles_lock);
-    if (auto o = GetHandle(handle); o) {
-        auto handle_description = &o->get();
+    std::weak_ptr<Handle> hWeak{GetHandle(handle)};
+    FreeInfo freeInfo;
+
+    // We use a weak ptr here so we can tell when the handle has been freed and report that back to
+    // guest
+    if (auto handle_description = hWeak.lock()) {
+        std::scoped_lock lock(handle_description->mutex);
+
         if (internal_session) {
             if (--handle_description->internal_dupes < 0)
                 LOG_WARNING(Service_NVDRV, "Internal duplicate count imbalance detected!");
@@ -258,25 +288,25 @@ std::optional<NvMap::FreeInfo> NvMap::FreeHandle(Handle::Id handle, bool interna
             } else if (handle_description->dupes == 0) {
                 // Force unmap the handle
                 if (handle_description->d_address) {
-                    std::scoped_lock ql(unmap_queue_lock);
+                    std::scoped_lock queueLock(unmap_queue_lock);
                     UnmapHandle(*handle_description);
                 }
+
                 handle_description->pins = 0;
             }
         }
+
         // Try to remove the shared ptr to the handle from the map, if nothing else is using the
         // handle then it will now be freed when `handle_description` goes out of scope
         if (TryRemoveHandle(*handle_description)) {
             LOG_DEBUG(Service_NVDRV, "Removed nvmap handle: {}", handle);
         } else {
-            LOG_DEBUG(Service_NVDRV, "Tried to free nvmap handle: {} but didn't as it still has duplicates", handle);
+            LOG_DEBUG(Service_NVDRV,
+                      "Tried to free nvmap handle: {} but didn't as it still has duplicates",
+                      handle);
         }
-        // // If the handle hasn't been freed from memory, mark that
-        // if (!hWeak.expired()) {
-        //     LOG_DEBUG(Service_NVDRV, "nvmap handle: {} wasn't freed as it is still in use", handle);
-        //     freeInfo.can_unlock = false;
-        // }
-        return FreeInfo{
+
+        freeInfo = {
             .address = handle_description->address,
             .size = handle_description->size,
             .was_uncached = handle_description->flags.map_uncached.Value() != 0,
@@ -285,15 +315,30 @@ std::optional<NvMap::FreeInfo> NvMap::FreeHandle(Handle::Id handle, bool interna
     } else {
         return std::nullopt;
     }
+
+    // If the handle hasn't been freed from memory, mark that
+    if (!hWeak.expired()) {
+        LOG_DEBUG(Service_NVDRV, "nvmap handle: {} wasn't freed as it is still in use", handle);
+        freeInfo.can_unlock = false;
+    }
+
+    return freeInfo;
 }
 
 void NvMap::UnmapAllHandles(NvCore::SessionId session_id) {
-    std::scoped_lock lk{handles_lock};
-    for (auto it = handles.begin(); it != handles.end(); ++it) {
-        if (it->second.session_id.id != session_id.id || it->second.dupes <= 0) {
-            continue;
+    auto handles_copy = [&] {
+        std::scoped_lock lk{handles_lock};
+        return handles;
+    }();
+
+    for (auto& [id, handle] : handles_copy) {
+        {
+            std::scoped_lock lk{handle->mutex};
+            if (handle->session_id.id != session_id.id || handle->dupes <= 0) {
+                continue;
+            }
         }
-        FreeHandle(it->first, false);
+        FreeHandle(id, false);
     }
 }
 

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

@@ -12,11 +12,6 @@
 #include <memory>
 #include <mutex>
 #include <optional>
-#if BOOST_VERSION >= 109000
-#include <boost/unordered/unordered_node_map.hpp>
-#else
-#include <unordered_map>
-#endif
 #include <ankerl/unordered_dense.h>
 #include <assert.h>
 
@@ -36,36 +31,54 @@ class Host1x;
 namespace Service::Nvidia::NvCore {
 
 class Container;
-/// @brief The nvmap core class holds the global state for nvmap and provides methods to manage handles
+/**
+ * @brief The nvmap core class holds the global state for nvmap and provides methods to manage
+ * handles
+ */
 class NvMap {
 public:
-    /// @brief A handle to a contiguous block of memory in an application's address space
+    /**
+     * @brief A handle to a contiguous block of memory in an application's address space
+     */
     struct Handle {
-        using Id = u32;
-        std::optional<typename std::list<Handle::Id>::iterator> unmap_queue_entry{};
+        std::mutex mutex;
+
         u64 align{};      //!< The alignment to use when pinning the handle onto the SMMU
         u64 size;         //!< Page-aligned size of the memory the handle refers to
         u64 aligned_size; //!< `align`-aligned size of the memory the handle refers to
         u64 orig_size;    //!< Original unaligned size of the memory this handle refers to
-        DAddr d_address{}; //!< The memory location in the device's AS that this handle corresponds to, this can also be in the nvdrv tmem
-        VAddr address{}; //!< The memory location in the guest's AS that this handle corresponds to, this can also be in the nvdrv tmem
-        s64 pins{};
+
         s32 dupes{1};          //!< How many guest references there are to this handle
         s32 internal_dupes{0}; //!< How many emulator-internal references there are to this handle
+
+        using Id = u32;
         Id id; //!< A globally unique identifier for this handle
+
+        s64 pins{};
         u32 pin_virt_address{};
+        std::optional<typename std::list<std::shared_ptr<Handle>>::iterator> unmap_queue_entry{};
+
         union Flags {
             u32 raw;
             BitField<0, 1, u32> map_uncached; //!< If the handle should be mapped as uncached
-            BitField<2, 1, u32> keep_uncached_after_free; //!< Only applicable when the handle was allocated with a fixed address
-            BitField<4, 1, u32> _unk0_; //!< Passed to IOVMM for pins
+            BitField<2, 1, u32> keep_uncached_after_free; //!< Only applicable when the handle was
+                                                          //!< allocated with a fixed address
+            BitField<4, 1, u32> _unk0_;                   //!< Passed to IOVMM for pins
         } flags{};
         static_assert(sizeof(Flags) == sizeof(u32));
-        NvCore::SessionId session_id{};
+
+        VAddr address{}; //!< The memory location in the guest's AS that this handle corresponds to,
+                         //!< this can also be in the nvdrv tmem
+        bool is_shared_mem_mapped{}; //!< If this nvmap has been mapped with the MapSharedMem IPC
+                                     //!< call
+
         u8 kind{};        //!< Used for memory compression
-        bool allocated : 1 = false; //!< If the handle has been allocated with `Alloc`
-        bool in_heap : 1 = false;
-        bool is_shared_mem_mapped : 1 = false; //!< If this nvmap has been mapped with the MapSharedMem IPC < call
+        bool allocated{}; //!< If the handle has been allocated with `Alloc`
+        bool in_heap{};
+        NvCore::SessionId session_id{};
+
+        DAddr d_address{}; //!< The memory location in the device's AS that this handle corresponds
+                           //!< to, this can also be in the nvdrv tmem
 
         Handle(u64 size, Id id);
 
@@ -110,9 +123,9 @@ public:
     /**
      * @brief Creates an unallocated handle of the given size
      */
-    [[nodiscard]] NvResult CreateHandle(u64 size, Handle::Id& out_handle);
+    [[nodiscard]] NvResult CreateHandle(u64 size, std::shared_ptr<NvMap::Handle>& result_out);
 
-    std::optional<std::reference_wrapper<Handle>> GetHandle(Handle::Id handle);
+    std::shared_ptr<Handle> GetHandle(Handle::Id handle);
 
     DAddr GetHandleAddress(Handle::Id handle);
 
@@ -144,21 +157,20 @@ public:
 
     void UnmapAllHandles(NvCore::SessionId session_id);
 
-    std::list<Handle::Id> unmap_queue{};
-    /// Main owning map of handles
-#if BOOST_VERSION >= 109000
-    boost::unordered_node_map<Handle::Id, Handle> handles{};
-#else
-    std::unordered_map<Handle::Id, Handle> handles{};
-#endif
+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>>
+        handles{};           //!< Main owning map of handles
     std::mutex handles_lock; //!< Protects access to `handles`
-    static constexpr u32 HandleIdIncrement{4}; //!< Each new handle ID is an increment of 4 from the previous
+
+    static constexpr u32 HandleIdIncrement{
+        4}; //!< Each new handle ID is an increment of 4 from the previous
     std::atomic<u32> next_handle_id{HandleIdIncrement};
     Tegra::Host1x::Host1x& host1x;
-    Container& core;
 
-    void AddHandle(Handle&& handle);
+    void AddHandle(std::shared_ptr<Handle> handle);
 
     /**
      * @brief Unmaps and frees the SMMU memory region a handle is mapped to
@@ -172,5 +184,7 @@ public:
      * @return If the handle was removed from the map
      */
     bool TryRemoveHandle(const Handle& handle_description);
+
+    Container& core;
 };
 } // namespace Service::Nvidia::NvCore

src/core/hle/service/nvdrv/devices/nvhost_as_gpu.cpp

@@ -328,11 +328,10 @@ NvResult nvhost_as_gpu::MapBufferEx(IoctlMapBufferEx& params) {
         }
     }
 
-    auto o = nvmap.GetHandle(params.handle);
-    if (!o) {
+    auto handle{nvmap.GetHandle(params.handle)};
+    if (!handle) {
         return NvResult::BadValue;
     }
-    auto handle = &o->get();
 
     DAddr device_address = DAddr(nvmap.PinHandle(params.handle, false) + params.buffer_offset);
     u64 size{params.mapping_size ? params.mapping_size : handle->orig_size};

src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.cpp

@@ -103,13 +103,17 @@ NvResult nvhost_nvdec_common::Submit(IoctlSubmit& params, std::span<u8> data, De
 
     for (std::size_t i = 0; i < syncpt_increments.size(); i++) {
         const SyncptIncr& syncpt_incr = syncpt_increments[i];
-        fence_thresholds[i] = syncpoint_manager.IncrementSyncpointMaxExt(syncpt_incr.id, syncpt_incr.increments);
+        fence_thresholds[i] =
+            syncpoint_manager.IncrementSyncpointMaxExt(syncpt_incr.id, syncpt_incr.increments);
     }
 
     for (const auto& cmd_buffer : command_buffers) {
         const auto object = nvmap.GetHandle(cmd_buffer.memory_id);
         ASSERT_OR_EXECUTE(object, return NvResult::InvalidState;);
-        Core::Memory::CpuGuestMemory<Tegra::ChCommandHeader, Core::Memory::GuestMemoryFlags::SafeRead> cmdlist(session->process->GetMemory(), object->get().address + cmd_buffer.offset, cmd_buffer.word_count);
+        Core::Memory::CpuGuestMemory<Tegra::ChCommandHeader,
+                                     Core::Memory::GuestMemoryFlags::SafeRead>
+            cmdlist(session->process->GetMemory(), object->address + cmd_buffer.offset,
+                    cmd_buffer.word_count);
         host1x.PushEntries(fd, std::move(cmdlist));
     }
 

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

@@ -83,14 +83,17 @@ void nvmap::OnClose(DeviceFD fd) {
 NvResult nvmap::IocCreate(IocCreateParams& params) {
     LOG_DEBUG(Service_NVDRV, "called, size={:#08x}", params.size);
 
-    NvCore::NvMap::Handle handle_description(0, 0);
-    // Orig size is the unaligned size, set the handle to that
-    auto result = file.CreateHandle(params.size, params.handle);
+    std::shared_ptr<NvCore::NvMap::Handle> handle_description{};
+    auto result =
+        file.CreateHandle(Common::AlignUp(params.size, YUZU_PAGESIZE), handle_description);
     if (result != NvResult::Success) {
         LOG_CRITICAL(Service_NVDRV, "Failed to create Object");
         return result;
     }
-    LOG_DEBUG(Service_NVDRV, "handle: {}, size: {:#x}", params.handle, params.size);
+    handle_description->orig_size = params.size; // Orig size is the unaligned size
+    params.handle = handle_description->id;
+    LOG_DEBUG(Service_NVDRV, "handle: {}, size: {:#x}", handle_description->id, params.size);
+
     return NvResult::Success;
 }
 
@@ -112,27 +115,30 @@ NvResult nvmap::IocAlloc(IocAllocParams& params, DeviceFD fd) {
         params.align = YUZU_PAGESIZE;
     }
 
-    std::scoped_lock lock(file.handles_lock);
-    auto o = file.GetHandle(params.handle);
-    if (!o) {
+    auto handle_description{file.GetHandle(params.handle)};
+    if (!handle_description) {
         LOG_CRITICAL(Service_NVDRV, "Object does not exist, handle={:08X}", params.handle);
         return NvResult::BadValue;
     }
 
-    auto handle_description = &o->get();
     if (handle_description->allocated) {
         LOG_CRITICAL(Service_NVDRV, "Object is already allocated, handle={:08X}", params.handle);
         return NvResult::InsufficientMemory;
     }
 
-    const auto result = handle_description->Alloc(params.flags, params.align, params.kind, params.address, sessions[fd]);
+    const auto result = handle_description->Alloc(params.flags, params.align, params.kind,
+                                                  params.address, sessions[fd]);
     if (result != NvResult::Success) {
         LOG_CRITICAL(Service_NVDRV, "Object failed to allocate, handle={:08X}", params.handle);
         return result;
     }
     bool is_out_io{};
     auto process = container.GetSession(sessions[fd])->process;
-    ASSERT(process->GetPageTable().LockForMapDeviceAddressSpace(&is_out_io, handle_description->address, handle_description->size, Kernel::KMemoryPermission::None, true, false).IsSuccess());
+    ASSERT(process->GetPageTable()
+               .LockForMapDeviceAddressSpace(&is_out_io, handle_description->address,
+                                             handle_description->size,
+                                             Kernel::KMemoryPermission::None, true, false)
+               .IsSuccess());
     return result;
 }
 
@@ -145,13 +151,13 @@ NvResult nvmap::IocGetId(IocGetIdParams& params) {
         return NvResult::BadValue;
     }
 
-    std::scoped_lock lock(file.handles_lock);
-    auto o = file.GetHandle(params.handle);
-    if (!o) {
+    auto handle_description{file.GetHandle(params.handle)};
+    if (!handle_description) {
         LOG_CRITICAL(Service_NVDRV, "Error!");
-        return NvResult::AccessDenied; // This will always return EPERM irrespective of if the handle exists or not
+        return NvResult::AccessDenied; // This will always return EPERM irrespective of if the
+                                       // handle exists or not
     }
-    auto handle_description = &o->get();
+
     params.id = handle_description->id;
     return NvResult::Success;
 }
@@ -168,14 +174,12 @@ NvResult nvmap::IocFromId(IocFromIdParams& params) {
         return NvResult::BadValue;
     }
 
-    std::scoped_lock lock(file.handles_lock);
-    auto o = file.GetHandle(params.id);
-    if (!o) {
+    auto handle_description{file.GetHandle(params.id)};
+    if (!handle_description) {
         LOG_CRITICAL(Service_NVDRV, "Unregistered handle!");
         return NvResult::BadValue;
     }
 
-    auto handle_description = &o->get();
     auto result = handle_description->Duplicate(false);
     if (result != NvResult::Success) {
         LOG_CRITICAL(Service_NVDRV, "Could not duplicate handle!");
@@ -195,14 +199,12 @@ NvResult nvmap::IocParam(IocParamParams& params) {
         return NvResult::BadValue;
     }
 
-    std::scoped_lock lock(file.handles_lock);
-    auto o = file.GetHandle(params.handle);
-    if (!o) {
+    auto handle_description{file.GetHandle(params.handle)};
+    if (!handle_description) {
         LOG_CRITICAL(Service_NVDRV, "Not registered handle!");
         return NvResult::BadValue;
     }
 
-    auto handle_description = &o->get();
     switch (params.param) {
     case HandleParameterType::Size:
         params.result = static_cast<u32_le>(handle_description->orig_size);