Smol change

src/android/app/src/main/java/org/yuzu/yuzu_emu/NativeLibrary.kt

@@ -218,6 +218,8 @@ object NativeLibrary {
 
     external fun logSettings()
 
+    external fun refreshThreadPolicies()
+
     external fun getDebugKnobAt(index: Int): Boolean
 
     /**

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/EmulationFragment.kt

@@ -1451,6 +1451,7 @@ class EmulationFragment : Fragment(), SurfaceHolder.Callback {
 
     override fun onResume() {
         super.onResume()
+        NativeLibrary.refreshThreadPolicies()
         val b = _binding ?: return
         updateStatsPosition(IntSetting.PERF_OVERLAY_POSITION.getInt())
         updateSocPosition(IntSetting.SOC_OVERLAY_POSITION.getInt())

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

@@ -50,6 +50,7 @@ extern "C" {
 #include "common/scope_exit.h"
 #include "common/settings.h"
 #include "common/string_util.h"
+#include "common/thread.h"
 #include "frontend_common/play_time_manager.h"
 #include "core/constants.h"
 #include "core/core.h"
@@ -1182,6 +1183,10 @@ void Java_org_yuzu_yuzu_1emu_NativeLibrary_logSettings(JNIEnv* env, jobject jobj
     Settings::LogSettings();
 }
 
+void Java_org_yuzu_yuzu_1emu_NativeLibrary_refreshThreadPolicies(JNIEnv* env, jobject jobj) {
+    Common::RefreshThreadPolicies();
+}
+
 jboolean Java_org_yuzu_yuzu_1emu_NativeLibrary_getDebugKnobAt(JNIEnv* env, jobject jobj, jint index) {
     return static_cast<jboolean>(Settings::getDebugKnobAt(static_cast<u8>(index)));
 }

src/common/host_memory.cpp

@@ -78,15 +78,9 @@ struct NativeHandle {
 };
 
 using PFN_AHardwareBuffer_getNativeHandle = const NativeHandle* (*)(const AHardwareBuffer*);
-using PFN_AHardwareBuffer_isSupported = int (*)(const AHardwareBuffer_Desc*);
-
-void* NativeWindowLibrary() {
-    static void* const lib = dlopen("libnativewindow.so", RTLD_NOW);
-    return lib;
-}
 
 PFN_AHardwareBuffer_getNativeHandle ResolveGetNativeHandle() {
-    void* const lib = NativeWindowLibrary();
+    void* const lib = dlopen("libnativewindow.so", RTLD_NOW);
     if (lib == nullptr) {
         return nullptr;
     }
@@ -94,15 +88,6 @@ PFN_AHardwareBuffer_getNativeHandle ResolveGetNativeHandle() {
         dlsym(lib, "AHardwareBuffer_getNativeHandle"));
 }
 
-PFN_AHardwareBuffer_isSupported ResolveIsSupported() {
-    void* const lib = NativeWindowLibrary();
-    if (lib == nullptr) {
-        return nullptr;
-    }
-    return reinterpret_cast<PFN_AHardwareBuffer_isSupported>(
-        dlsym(lib, "AHardwareBuffer_isSupported"));
-}
-
 } // namespace
 #endif
 
@@ -175,7 +160,7 @@ static void GetFuncAddress(Common::DynamicLibrary& dll, const char* name, T& pfn
 
 class HostMemory::Impl {
 public:
-    explicit Impl(size_t backing_size_, size_t virtual_size_)
+    explicit Impl(size_t backing_size_, size_t virtual_size_, size_t)
         : backing_size{backing_size_}
         , virtual_size{virtual_size_}
         , process{GetCurrentProcess()}
@@ -281,6 +266,10 @@ public:
         UNREACHABLE();
     }
 
+    bool IsBackingShared() const noexcept {
+        return true;
+    }
+
     const size_t backing_size; ///< Size of the backing memory in bytes
     const size_t virtual_size; ///< Size of the virtual address placeholder in bytes
 
@@ -553,19 +542,15 @@ static int shm_open_anon(int flags, mode_t mode) {
 
 class HostMemory::Impl {
 public:
-    explicit Impl(size_t backing_size_, size_t virtual_size_)
+    explicit Impl(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_)
         : backing_size{backing_size_}
         , virtual_size{virtual_size_}
+        , preferred_offset{preferred_offset_}
     {}
 
     bool Init() {
         long page_size = sysconf(_SC_PAGESIZE);
         ASSERT_MSG(page_size == 0x1000, "page size {:#x} is incompatible with 4K paging", page_size);
-#ifdef __ANDROID__
-        if (InitAhbBacking()) {
-            return InitVirtual();
-        }
-#endif
         // Backing memory initialization
 #if defined(__sun__) || defined(__HAIKU__) || defined(__NetBSD__) || defined(__DragonFly__)
         fd = shm_open_anon(O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW, 0600);
@@ -600,10 +585,15 @@ public:
             LOG_WARNING(Common_Memory, "Using private mappings instead of shared ones");
             backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0));
             if (fd > 0) {
-                fd = -1;
                 close(fd);
             }
+            fd = -1;
         } else {
+#ifdef __ANDROID__
+            if (InitAhbBacking()) {
+                return InitVirtual();
+            }
+#endif
             backing_base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0));
         }
         if (backing_base == MAP_FAILED) {
@@ -680,6 +670,46 @@ public:
         return ok;
     }
 
+    size_t ComputeAhbBudget(size_t window_size) const {
+        const u64 total_physical = Common::GetMemInfo().TotalPhysicalMemory;
+        if (total_physical == 0) {
+            LOG_WARNING(HW_Memory, "Host memory size is unknown, not committing hardware buffers");
+            return 0;
+        }
+        constexpr u64 MinimumTotalPhysical = 7ULL << 30;
+        if (total_physical < MinimumTotalPhysical) {
+            LOG_INFO(HW_Memory,
+                     "Skipping hardware buffer backing, {} MiB of RAM is below the {} MiB minimum",
+                     total_physical >> 20, MinimumTotalPhysical >> 20);
+            return 0;
+        }
+        const u64 max_map_count = Common::GetMaxMapCount();
+        constexpr u64 ReservedMaps = 24576;
+        if (max_map_count == 0 || max_map_count <= ReservedMaps) {
+            LOG_WARNING(HW_Memory,
+                        "Skipping hardware buffer backing, vm.max_map_count is unknown or too low");
+            return 0;
+        }
+        u64 budget = total_physical / 6;
+        budget = (std::min)(budget, (max_map_count - ReservedMaps) * PageAlignment);
+        const u64 available = Common::GetAvailablePhysicalMemory();
+        if (available != 0) {
+            constexpr u64 Headroom = 2ULL << 30;
+            budget = (std::min)(budget, available > Headroom ? available - Headroom : 0);
+        }
+        budget = (std::min)(budget, static_cast<u64>(backing_size));
+        budget = Common::AlignDown(budget, window_size);
+        constexpr u64 MinimumBudget = 256ULL << 20;
+        if (budget < MinimumBudget) {
+            LOG_INFO(HW_Memory,
+                     "Skipping hardware buffer backing, only {} MiB could be committed on a {} MiB "
+                     "system with {} MiB available and vm.max_map_count {}",
+                     budget >> 20, total_physical >> 20, available >> 20, max_map_count);
+            return 0;
+        }
+        return static_cast<size_t>(budget);
+    }
+
     bool InitAhbBacking() {
         if (!Settings::values.use_unified_memory.GetValue()) {
             return false;
@@ -690,106 +720,130 @@ public:
             LOG_WARNING(HW_Memory, "AHardwareBuffer_getNativeHandle is not available");
             return false;
         }
-        static const PFN_AHardwareBuffer_isSupported is_supported = ResolveIsSupported();
-        if (is_supported == nullptr) {
-            LOG_WARNING(HW_Memory, "AHardwareBuffer_isSupported is not available");
+        constexpr size_t window_size = 64ULL << 20;
+        const AHardwareBuffer_Desc window_desc = MakeBlobDesc(window_size);
+        if (AHardwareBuffer_isSupported(&window_desc) == 0) {
+            LOG_WARNING(HW_Memory, "Allocator rejects {} MiB hardware buffer windows",
+                        window_size >> 20);
             return false;
         }
-        const u64 total_physical = Common::GetMemInfo().TotalPhysicalMemory;
-        if (total_physical != 0 && backing_size > total_physical / 2) {
-            LOG_WARNING(HW_Memory,
-                        "Hardware buffer backing would commit {} MiB on a {} MiB system, keeping "
-                        "lazily committed memory",
-                        backing_size >> 20, total_physical >> 20);
+        const size_t budget = ComputeAhbBudget(window_size);
+        if (budget == 0) {
             return false;
         }
         if (!ProbeAhbBacking(get_native_handle)) {
             return false;
         }
-        const auto try_window_size = [&](size_t window_size) -> bool {
-            const size_t num_windows = (backing_size + window_size - 1) / window_size;
-            std::vector<AHardwareBuffer*> buffers;
-            std::vector<int> buffer_fds;
-            const auto cleanup = [&] {
-                for (AHardwareBuffer* buffer : buffers) {
-                    AHardwareBuffer_release(buffer);
-                }
-                buffers.clear();
-                buffer_fds.clear();
-            };
-            for (size_t i = 0; i < num_windows; ++i) {
-                const size_t len = (std::min)(window_size, backing_size - i * window_size);
-                const AHardwareBuffer_Desc desc = MakeBlobDesc(len);
-                AHardwareBuffer* buffer{};
-                if (AHardwareBuffer_allocate(&desc, &buffer) != 0 || buffer == nullptr) {
-                    LOG_WARNING(HW_Memory, "Hardware buffer allocation failed for window {}", i);
-                    cleanup();
-                    return false;
-                }
-                buffers.push_back(buffer);
-                const NativeHandle* const handle = get_native_handle(buffer);
-                if (handle == nullptr || handle->numFds < 1) {
-                    LOG_WARNING(HW_Memory, "Hardware buffer has no mappable file descriptor");
-                    cleanup();
-                    return false;
-                }
-                const int buffer_fd = handle->data[0];
-                const off_t buffer_len = lseek(buffer_fd, 0, SEEK_END);
-                if (buffer_len < static_cast<off_t>(len)) {
-                    LOG_WARNING(HW_Memory, "Hardware buffer descriptor smaller than requested");
-                    cleanup();
-                    return false;
-                }
-                buffer_fds.push_back(buffer_fd);
+        const size_t aligned_backing = Common::AlignDown(backing_size, window_size);
+        const size_t region_size = (std::min)(budget, aligned_backing);
+        const size_t region_base = Common::AlignDown(
+            (std::min)(preferred_offset, aligned_backing - region_size), window_size);
+        const size_t num_windows = region_size / window_size;
+
+        std::vector<AHardwareBuffer*> buffers;
+        std::vector<int> buffer_fds;
+        const auto cleanup = [&] {
+            for (AHardwareBuffer* buffer : buffers) {
+                AHardwareBuffer_release(buffer);
             }
-            u8* const base =
-                static_cast<u8*>(mmap(nullptr, backing_size, PROT_NONE,
-                                      MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0));
-            if (base == MAP_FAILED) {
+            buffers.clear();
+            buffer_fds.clear();
+        };
+        for (size_t i = 0; i < num_windows; ++i) {
+            const AHardwareBuffer_Desc desc = MakeBlobDesc(window_size);
+            AHardwareBuffer* buffer{};
+            if (AHardwareBuffer_allocate(&desc, &buffer) != 0 || buffer == nullptr) {
+                LOG_WARNING(HW_Memory, "Hardware buffer allocation failed for window {} of {}", i,
+                            num_windows);
                 cleanup();
                 return false;
             }
-            for (size_t i = 0; i < num_windows; ++i) {
-                const size_t len = (std::min)(window_size, backing_size - i * window_size);
-                if (mmap(base + i * window_size, len, PROT_READ | PROT_WRITE,
-                         MAP_SHARED | MAP_FIXED, buffer_fds[i], 0) == MAP_FAILED) {
-                    LOG_WARNING(HW_Memory, "Hardware buffer mmap failed: {}", strerror(errno));
-                    munmap(base, backing_size);
-                    cleanup();
-                    return false;
-                }
+            buffers.push_back(buffer);
+            const NativeHandle* const handle = get_native_handle(buffer);
+            if (handle == nullptr || handle->numFds < 1) {
+                LOG_WARNING(HW_Memory, "Hardware buffer has no mappable file descriptor");
+                cleanup();
+                return false;
             }
-            backing_base = base;
-            ahb_windows = std::move(buffers);
-            ahb_fds = std::move(buffer_fds);
-            ahb_window_size = window_size;
-            ahb_backing = true;
-            committed_backing_size.store(backing_size, std::memory_order_relaxed);
-            LOG_INFO(HW_Memory,
-                     "Guest memory backed by {} hardware buffer windows of {} MiB, {} MiB committed",
-                     ahb_windows.size(), window_size >> 20, backing_size >> 20);
-            return true;
-        };
-        static constexpr size_t candidate_window_sizes[] = {
-            1024ULL << 20,
-            512ULL << 20,
-            256ULL << 20,
-            128ULL << 20,
-        };
-        for (const size_t candidate : candidate_window_sizes) {
-            const AHardwareBuffer_Desc window_desc = MakeBlobDesc(candidate);
-            if (is_supported(&window_desc) == 0) {
-                LOG_DEBUG(HW_Memory, "Allocator rejects {} MiB hardware buffer windows",
-                          candidate >> 20);
-                continue;
+            const int buffer_fd = handle->data[0];
+            const off_t buffer_len = lseek(buffer_fd, 0, SEEK_END);
+            if (buffer_len < static_cast<off_t>(window_size)) {
+                LOG_WARNING(HW_Memory, "Hardware buffer descriptor smaller than requested");
+                cleanup();
+                return false;
             }
-            if (try_window_size(candidate)) {
+            buffer_fds.push_back(buffer_fd);
+        }
+        u8* const base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_NONE,
+                                               MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0));
+        if (base == MAP_FAILED) {
+            LOG_WARNING(HW_Memory, "Failed to reserve backing address space: {}", strerror(errno));
+            cleanup();
+            return false;
+        }
+        const auto map_over_reservation = [&](size_t offset, size_t len, int map_fd,
+                                              off_t map_offset) {
+            if (len == 0) {
                 return true;
             }
-            LOG_WARNING(HW_Memory, "Could not back guest memory with {} MiB windows",
-                        candidate >> 20);
+            if (mmap(base + offset, len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, map_fd,
+                     map_offset) == MAP_FAILED) {
+                LOG_WARNING(HW_Memory, "Backing mmap failed: {}", strerror(errno));
+                munmap(base, backing_size);
+                cleanup();
+                return false;
+            }
+            return true;
+        };
+        if (!map_over_reservation(0, region_base, fd, 0)) {
+            return false;
+        }
+        for (size_t i = 0; i < num_windows; ++i) {
+            if (!map_over_reservation(region_base + i * window_size, window_size, buffer_fds[i],
+                                      0)) {
+                return false;
+            }
+        }
+        const size_t tail_offset = region_base + region_size;
+        if (!map_over_reservation(tail_offset, backing_size - tail_offset, fd,
+                                  static_cast<off_t>(tail_offset))) {
+            return false;
+        }
+        backing_base = base;
+        ahb_windows = std::move(buffers);
+        ahb_fds = std::move(buffer_fds);
+        ahb_window_size = window_size;
+        ahb_base = region_base;
+        ahb_bytes = region_size;
+        committed_backing_size.store(region_size, std::memory_order_relaxed);
+        LOG_INFO(HW_Memory,
+                 "Guest memory {:#x}-{:#x} backed by {} hardware buffer windows, {} MiB committed",
+                 region_base, region_base + region_size, ahb_windows.size(), region_size >> 20);
+        return true;
+    }
+
+    void MapBackingRange(size_t virtual_offset, size_t host_offset, size_t length, int prot_flags) {
+        while (length > 0) {
+            int map_fd = fd;
+            off_t map_offset = static_cast<off_t>(host_offset);
+            size_t chunk = length;
+            if (host_offset < ahb_base) {
+                chunk = (std::min)(chunk, ahb_base - host_offset);
+            } else if (host_offset < ahb_base + ahb_bytes) {
+                const size_t relative = host_offset - ahb_base;
+                const size_t window = relative / ahb_window_size;
+                const size_t local = relative % ahb_window_size;
+                map_fd = ahb_fds[window];
+                map_offset = static_cast<off_t>(local);
+                chunk = (std::min)(chunk, ahb_window_size - local);
+            }
+            void* const ret = mmap(virtual_base + virtual_offset, chunk, prot_flags,
+                                   MAP_SHARED | MAP_FIXED, map_fd, map_offset);
+            ASSERT_MSG(ret != MAP_FAILED, "mmap: {}", strerror(errno));
+            virtual_offset += chunk;
+            host_offset += chunk;
+            length -= chunk;
         }
-        return false;
     }
 
     std::span<AHardwareBuffer* const> AhbWindows() const noexcept {
@@ -797,7 +851,11 @@ public:
     }
 
     size_t AhbWindowSize() const noexcept {
-        return ahb_backing ? ahb_window_size : 0;
+        return ahb_bytes != 0 ? ahb_window_size : 0;
+    }
+
+    size_t AhbBase() const noexcept {
+        return ahb_base;
     }
 #endif
 
@@ -823,22 +881,8 @@ public:
             prot_flags |= PROT_EXEC;
 #endif
 #ifdef __ANDROID__
-        if (ahb_backing) {
-            size_t voff = virtual_offset;
-            size_t hoff = host_offset;
-            size_t remaining = length;
-            while (remaining > 0) {
-                const size_t window = hoff / ahb_window_size;
-                const size_t local = hoff % ahb_window_size;
-                const size_t chunk = (std::min)(remaining, ahb_window_size - local);
-                void* const ret =
-                    mmap(virtual_base + voff, chunk, prot_flags, MAP_SHARED | MAP_FIXED,
-                         ahb_fds[window], static_cast<off_t>(local));
-                ASSERT_MSG(ret != MAP_FAILED, "mmap: {}", strerror(errno));
-                voff += chunk;
-                hoff += chunk;
-                remaining -= chunk;
-            }
+        if (ahb_bytes != 0) {
+            MapBackingRange(virtual_offset, host_offset, length, prot_flags);
             return;
         }
 #endif
@@ -886,8 +930,18 @@ public:
         virtual_base = nullptr;
     }
 
+    bool IsBackingShared() const noexcept {
+#ifdef __ANDROID__
+        if (ahb_bytes != 0) {
+            return true;
+        }
+#endif
+        return fd >= 0;
+    }
+
     const size_t backing_size; ///< Size of the backing memory in bytes
     const size_t virtual_size; ///< Size of the virtual address placeholder in bytes
+    const size_t preferred_offset;
 
     u8* backing_base{reinterpret_cast<u8*>(MAP_FAILED)};
     u8* virtual_base{reinterpret_cast<u8*>(MAP_FAILED)};
@@ -917,9 +971,9 @@ private:
         }
         ahb_windows.clear();
         ahb_fds.clear();
-        if (ahb_backing) {
+        if (ahb_bytes != 0) {
             committed_backing_size.store(0, std::memory_order_relaxed);
-            ahb_backing = false;
+            ahb_bytes = 0;
         }
 #endif
     }
@@ -949,16 +1003,17 @@ private:
     FreeRegionManager free_manager{};
 
 #ifdef __ANDROID__
-    bool ahb_backing{};
     std::vector<AHardwareBuffer*> ahb_windows;
     std::vector<int> ahb_fds;
     size_t ahb_window_size{};
+    size_t ahb_base{};
+    size_t ahb_bytes{};
 #endif
 };
 
 #endif // ^^^ POSIX ^^^
 
-HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
+HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_)
     : backing_size(backing_size_)
     , virtual_size(virtual_size_)
 {
@@ -970,7 +1025,7 @@ HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_)
 #else
     // Try to allocate a fastmem arena.
     // The implementation will fail with std::bad_alloc on errors.
-    impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize);
+    impl = std::make_unique<HostMemory::Impl>(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize, preferred_offset_);
     if (impl->Init()) {
         backing_base = impl->backing_base;
         virtual_base = impl->virtual_base;
@@ -1056,6 +1111,22 @@ size_t HostMemory::BackingHardwareBufferWindowSize() const noexcept {
 #endif
 }
 
+bool HostMemory::IsBackingShared() const noexcept {
+#if defined(__OPENORBIS__) || defined(__managarm__)
+    return false;
+#else
+    return impl && impl->IsBackingShared();
+#endif
+}
+
+size_t HostMemory::BackingHardwareBufferBase() const noexcept {
+#ifdef __ANDROID__
+    return impl ? impl->AhbBase() : 0;
+#else
+    return 0;
+#endif
+}
+
 void HostMemory::EnableDirectMappedAddress() {
 #if !(defined(__OPENORBIS__) || defined(__managarm__))
     if (impl) {

src/common/host_memory.h

@@ -33,7 +33,7 @@ DECLARE_ENUM_FLAG_OPERATORS(MemoryPermission)
  */
 class HostMemory {
 public:
-    explicit HostMemory(size_t backing_size_, size_t virtual_size_);
+    explicit HostMemory(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_ = 0);
     ~HostMemory();
 
     /**
@@ -75,6 +75,10 @@ public:
 
     [[nodiscard]] size_t BackingHardwareBufferWindowSize() const noexcept;
 
+    [[nodiscard]] size_t BackingHardwareBufferBase() const noexcept;
+
+    [[nodiscard]] bool IsBackingShared() const noexcept;
+
     [[nodiscard]] u8* VirtualBasePointer() noexcept {
         return virtual_base;
     }

src/common/memory_detect.cpp

@@ -17,6 +17,10 @@
 #endif
 #endif
 
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
 #include "common/memory_detect.h"
 
 namespace Common {
@@ -69,4 +73,55 @@ const MemoryInfo& GetMemInfo() {
     return mem_info;
 }
 
+u64 GetAvailablePhysicalMemory() {
+#ifdef _WIN32
+    MEMORYSTATUSEX memorystatus;
+    memorystatus.dwLength = sizeof(memorystatus);
+    if (GlobalMemoryStatusEx(&memorystatus)) {
+        return memorystatus.ullAvailPhys;
+    }
+    return 0;
+#elif defined(__linux__)
+    if (std::FILE* const file = std::fopen("/proc/meminfo", "re")) {
+        char line[256];
+        u64 available = 0;
+        while (std::fgets(line, sizeof(line), file) != nullptr) {
+            if (std::strncmp(line, "MemAvailable:", 13) == 0) {
+                available = std::strtoull(line + 13, nullptr, 10) * 1024ULL;
+                break;
+            }
+        }
+        std::fclose(file);
+        if (available != 0) {
+            return available;
+        }
+    }
+    struct sysinfo info;
+    if (sysinfo(&info) == 0) {
+        const u64 unit = info.mem_unit != 0 ? info.mem_unit : 1ULL;
+        return (static_cast<u64>(info.freeram) + static_cast<u64>(info.bufferram)) * unit;
+    }
+    return 0;
+#else
+    return 0;
+#endif
+}
+
+u64 GetMaxMapCount() {
+#ifdef __linux__
+    if (std::FILE* const file = std::fopen("/proc/sys/vm/max_map_count", "re")) {
+        char line[32];
+        u64 count = 0;
+        if (std::fgets(line, sizeof(line), file) != nullptr) {
+            count = std::strtoull(line, nullptr, 10);
+        }
+        std::fclose(file);
+        return count;
+    }
+    return 0;
+#else
+    return 0;
+#endif
+}
+
 } // namespace Common

src/common/memory_detect.h

@@ -18,4 +18,8 @@ struct MemoryInfo {
  */
 [[nodiscard]] const MemoryInfo& GetMemInfo();
 
+[[nodiscard]] u64 GetAvailablePhysicalMemory();
+
+[[nodiscard]] u64 GetMaxMapCount();
+
 } // namespace Common

src/common/thread.cpp

@@ -43,103 +43,251 @@
 #ifdef __ANDROID__
 #include <sys/resource.h>
 #include <algorithm>
+#include <cstdlib>
+#include <cstring>
 #include <fstream>
+#include <mutex>
 #include <utility>
 #include <vector>
 
 namespace {
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_URGENT_AUDIO = -19;
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_AUDIO = -16;
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_URGENT_DISPLAY = -8;
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_DISPLAY = -4;
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_FOREGROUND = -2;
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_MORE_FAVORABLE = -1;
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_DEFAULT = 0;
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_LESS_FAVORABLE = 1;
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_BACKGROUND = 10;
-[[maybe_unused]] constexpr int ANDROID_THREAD_PRIORITY_LOWEST = 19;
+constexpr int ANDROID_THREAD_PRIORITY_AUDIO = -16;
+constexpr int ANDROID_THREAD_PRIORITY_URGENT_DISPLAY = -8;
+constexpr int ANDROID_THREAD_PRIORITY_DISPLAY = -4;
+constexpr int ANDROID_THREAD_PRIORITY_DEFAULT = 0;
+constexpr int ANDROID_THREAD_PRIORITY_BACKGROUND = 10;
 
 constexpr size_t ANDROID_MINIMUM_PERFORMANCE_CORES = 4;
 
-cpu_set_t ComputePerformanceCoreMask() {
-    cpu_set_t mask;
-    CPU_ZERO(&mask);
+enum class CoreGroup {
+    Unrestricted,
+    Performance,
+    Efficiency,
+};
 
+struct CoreTopology {
     cpu_set_t allowed;
-    CPU_ZERO(&allowed);
-    if (sched_getaffinity(gettid(), sizeof(allowed), &allowed) != 0) {
-        return mask;
-    }
+    cpu_set_t performance;
+    cpu_set_t efficiency;
+    bool separated;
+    bool initialized;
+};
 
+struct ThreadPolicy {
+    pid_t tid;
+    CoreGroup group;
+    int nice_value;
+    bool has_nice;
+};
+
+std::mutex g_topology_mutex;
+CoreTopology g_topology{};
+
+std::mutex g_policy_mutex;
+
+std::vector<ThreadPolicy>& Policies() {
+    static auto* const policies = new std::vector<ThreadPolicy>();
+    return *policies;
+}
+
+struct PolicyRegistration {
+    ~PolicyRegistration() {
+        const pid_t tid = gettid();
+        std::scoped_lock lock{g_policy_mutex};
+        std::erase_if(Policies(), [tid](const ThreadPolicy& policy) { return policy.tid == tid; });
+    }
+};
+
+thread_local PolicyRegistration t_policy_registration;
+
+int PossibleCpuCount() {
+    std::ifstream file("/sys/devices/system/cpu/possible");
+    std::string list;
+    if (file && std::getline(file, list) && !list.empty()) {
+        int highest = -1;
+        const char* cursor = list.c_str();
+        while (*cursor != '\0') {
+            char* end = nullptr;
+            const long value = std::strtol(cursor, &end, 10);
+            if (end == cursor) {
+                break;
+            }
+            highest = (std::max)(highest, static_cast<int>(value));
+            cursor = end;
+            while (*cursor == '-' || *cursor == ',') {
+                ++cursor;
+            }
+        }
+        if (highest >= 0) {
+            return (std::min)(highest + 1, CPU_SETSIZE);
+        }
+    }
+    const long configured = sysconf(_SC_NPROCESSORS_CONF);
+    if (configured > 0) {
+        return static_cast<int>((std::min<long>)(configured, CPU_SETSIZE));
+    }
+    return static_cast<int>((std::min<unsigned>)(std::thread::hardware_concurrency(), CPU_SETSIZE));
+}
+
+long ReadCpuScalar(int cpu, const char* node) {
+    long value = 0;
+    std::ifstream file("/sys/devices/system/cpu/cpu" + std::to_string(cpu) + "/" + node);
+    if (!file || !(file >> value) || value <= 0) {
+        return 0;
+    }
+    return value;
+}
+
+std::vector<std::pair<long, int>> CollectCoreWeights(const cpu_set_t& allowed, int total,
+                                                     const char* node, bool require_all) {
     std::vector<std::pair<long, int>> cores;
-    const int total = static_cast<int>(std::thread::hardware_concurrency());
     for (int cpu = 0; cpu < total; ++cpu) {
         if (!CPU_ISSET(cpu, &allowed)) {
             continue;
         }
-        long max_frequency = 0;
-        std::ifstream file("/sys/devices/system/cpu/cpu" + std::to_string(cpu) +
-                           "/cpufreq/cpuinfo_max_freq");
-        if (!file || !(file >> max_frequency) || max_frequency <= 0) {
-            CPU_ZERO(&mask);
-            return mask;
+        const long weight = ReadCpuScalar(cpu, node);
+        if (weight <= 0) {
+            if (require_all) {
+                return {};
+            }
+            LOG_WARNING(Common, "Could not read {} for CPU {}, treating it as an efficiency core",
+                        node, cpu);
+            continue;
         }
-        cores.emplace_back(max_frequency, cpu);
+        cores.emplace_back(weight, cpu);
+    }
+    return cores;
+}
+
+void ComputeTopologyLocked() {
+    g_topology.initialized = true;
+    g_topology.separated = false;
+    CPU_ZERO(&g_topology.allowed);
+    CPU_ZERO(&g_topology.performance);
+    CPU_ZERO(&g_topology.efficiency);
+
+    if (sched_getaffinity(getpid(), sizeof(g_topology.allowed), &g_topology.allowed) != 0) {
+        LOG_WARNING(Common, "Could not query process CPU affinity: {}",
+                    ::Common::GetLastErrorMsg());
+        return;
+    }
+
+    const int total = PossibleCpuCount();
+    auto cores = CollectCoreWeights(g_topology.allowed, total, "cpu_capacity", true);
+    if (cores.empty()) {
+        cores = CollectCoreWeights(g_topology.allowed, total, "cpufreq/cpuinfo_max_freq", false);
     }
     if (cores.empty()) {
-        return mask;
+        LOG_WARNING(Common, "Could not determine CPU topology, thread placement is disabled");
+        return;
     }
 
     std::sort(cores.begin(), cores.end(),
               [](const auto& lhs, const auto& rhs) { return lhs.first > rhs.first; });
 
+    const size_t allowed_count = static_cast<size_t>(CPU_COUNT(&g_topology.allowed));
+    const size_t maximum =
+        allowed_count > 2 * ANDROID_MINIMUM_PERFORMANCE_CORES
+            ? allowed_count - ANDROID_MINIMUM_PERFORMANCE_CORES
+            : ANDROID_MINIMUM_PERFORMANCE_CORES;
+
     size_t taken = 0;
-    long cluster_frequency = cores.front().first;
-    for (const auto& [frequency, cpu] : cores) {
-        if (frequency != cluster_frequency) {
+    long cluster_weight = cores.front().first;
+    for (const auto& [weight, cpu] : cores) {
+        if (weight != cluster_weight) {
             if (taken >= ANDROID_MINIMUM_PERFORMANCE_CORES) {
                 break;
             }
-            cluster_frequency = frequency;
+            cluster_weight = weight;
         }
-        CPU_SET(cpu, &mask);
+        if (taken >= maximum) {
+            break;
+        }
+        CPU_SET(cpu, &g_topology.performance);
         ++taken;
     }
-    return mask;
-}
-
-const cpu_set_t& PerformanceCoreMask() {
-    static const cpu_set_t mask = ComputePerformanceCoreMask();
-    return mask;
-}
-
-cpu_set_t ComputeEfficiencyCoreMask() {
-    cpu_set_t mask;
-    CPU_ZERO(&mask);
-
-    const cpu_set_t& performance = PerformanceCoreMask();
-    if (CPU_COUNT(&performance) == 0) {
-        return mask;
+    if (taken == 0) {
+        return;
     }
 
-    cpu_set_t allowed;
-    CPU_ZERO(&allowed);
-    if (sched_getaffinity(gettid(), sizeof(allowed), &allowed) != 0) {
-        return mask;
-    }
-
-    const int total = static_cast<int>(std::thread::hardware_concurrency());
     for (int cpu = 0; cpu < total; ++cpu) {
-        if (CPU_ISSET(cpu, &allowed) && !CPU_ISSET(cpu, &performance)) {
-            CPU_SET(cpu, &mask);
+        if (CPU_ISSET(cpu, &g_topology.allowed) && !CPU_ISSET(cpu, &g_topology.performance)) {
+            CPU_SET(cpu, &g_topology.efficiency);
         }
     }
-    return mask;
+
+    g_topology.separated = CPU_COUNT(&g_topology.efficiency) > 0;
+    LOG_INFO(Common, "CPU topology: {} performance cores, {} efficiency cores, separation {}",
+             CPU_COUNT(&g_topology.performance), CPU_COUNT(&g_topology.efficiency),
+             g_topology.separated ? "enabled" : "unavailable");
 }
 
-const cpu_set_t& EfficiencyCoreMask() {
-    static const cpu_set_t mask = ComputeEfficiencyCoreMask();
-    return mask;
+void EnsureTopologyLocked() {
+    if (!g_topology.initialized) {
+        ComputeTopologyLocked();
+    }
+}
+
+void RefreshTopologyLocked() {
+    if (!g_topology.initialized) {
+        ComputeTopologyLocked();
+        return;
+    }
+    cpu_set_t current;
+    CPU_ZERO(&current);
+    if (sched_getaffinity(getpid(), sizeof(current), &current) != 0) {
+        return;
+    }
+    if (std::memcmp(&current, &g_topology.allowed, sizeof(current)) != 0) {
+        ComputeTopologyLocked();
+    }
+}
+
+bool ApplyCoreGroupLocked(pid_t tid, CoreGroup group) {
+    if (!g_topology.separated || group == CoreGroup::Unrestricted) {
+        return false;
+    }
+    const cpu_set_t& mask =
+        group == CoreGroup::Performance ? g_topology.performance : g_topology.efficiency;
+    if (CPU_COUNT(&mask) == 0) {
+        return false;
+    }
+    if (sched_setaffinity(tid, sizeof(mask), &mask) != 0) {
+        LOG_WARNING(Common, "Could not restrict thread {} to its core group: {}", tid,
+                    ::Common::GetLastErrorMsg());
+        return false;
+    }
+    return true;
+}
+
+ThreadPolicy& AcquirePolicyLocked(pid_t tid) {
+    auto& policies = Policies();
+    for (auto& policy : policies) {
+        if (policy.tid == tid) {
+            return policy;
+        }
+    }
+    return policies.emplace_back(ThreadPolicy{tid, CoreGroup::Unrestricted, 0, false});
+}
+
+void SetCurrentThreadCoreGroup(CoreGroup group) {
+    const pid_t tid = gettid();
+    {
+        std::scoped_lock lock{g_topology_mutex};
+        EnsureTopologyLocked();
+        ApplyCoreGroupLocked(tid, group);
+    }
+    (void)&t_policy_registration;
+    std::scoped_lock lock{g_policy_mutex};
+    AcquirePolicyLocked(tid).group = group;
+}
+
+void RememberCurrentThreadNice(pid_t tid, int nice_value) {
+    (void)&t_policy_registration;
+    std::scoped_lock lock{g_policy_mutex};
+    ThreadPolicy& policy = AcquirePolicyLocked(tid);
+    policy.nice_value = nice_value;
+    policy.has_nice = true;
 }
 } // Anonymous namespace
 #endif
@@ -153,7 +301,6 @@ const cpu_set_t& EfficiencyCoreMask() {
 #endif
 #include "common/x64/rdtsc.h"
 #endif
-#include "core/core_timing.h"
 
 namespace Common {
 
@@ -194,10 +341,13 @@ void SetCurrentThreadPriority(ThreadPriority new_priority) {
         default: return ANDROID_THREAD_PRIORITY_DEFAULT;
         }
     }();
-    if (setpriority(PRIO_PROCESS, static_cast<id_t>(gettid()), nice_value) != 0) {
-        LOG_DEBUG(Common, "Could not set thread nice value to {}: {}", nice_value,
-                  GetLastErrorMsg());
+    const pid_t tid = gettid();
+    if (setpriority(PRIO_PROCESS, static_cast<id_t>(tid), nice_value) != 0) {
+        LOG_WARNING(Common, "Could not set thread nice value to {}: {}", nice_value,
+                    GetLastErrorMsg());
+        return;
     }
+    RememberCurrentThreadNice(tid, nice_value);
 #else
     pthread_t this_thread = pthread_self();
     const auto scheduling_type = SCHED_OTHER;
@@ -254,24 +404,27 @@ void SetCurrentThreadName(const char* name) {
 
 void SetCurrentThreadToPerformanceCores() {
 #if defined(__ANDROID__)
-    const cpu_set_t& mask = PerformanceCoreMask();
-    if (CPU_COUNT(&mask) == 0) {
-        return;
-    }
-    if (sched_setaffinity(gettid(), sizeof(mask), &mask) != 0) {
-        LOG_DEBUG(Common, "Could not restrict thread to performance cores: {}", GetLastErrorMsg());
-    }
+    SetCurrentThreadCoreGroup(CoreGroup::Performance);
 #endif
 }
 
 void SetCurrentThreadToEfficiencyCores() {
 #if defined(__ANDROID__)
-    const cpu_set_t& mask = EfficiencyCoreMask();
-    if (CPU_COUNT(&mask) == 0) {
-        return;
-    }
-    if (sched_setaffinity(gettid(), sizeof(mask), &mask) != 0) {
-        LOG_DEBUG(Common, "Could not restrict thread to efficiency cores: {}", GetLastErrorMsg());
+    SetCurrentThreadCoreGroup(CoreGroup::Efficiency);
+#endif
+}
+
+void RefreshThreadPolicies() {
+#if defined(__ANDROID__)
+    std::scoped_lock topology_lock{g_topology_mutex};
+    RefreshTopologyLocked();
+
+    std::scoped_lock policy_lock{g_policy_mutex};
+    for (const auto& policy : Policies()) {
+        if (policy.has_nice) {
+            setpriority(PRIO_PROCESS, static_cast<id_t>(policy.tid), policy.nice_value);
+        }
+        ApplyCoreGroupLocked(policy.tid, policy.group);
     }
 #endif
 }

src/common/thread.h

@@ -102,11 +102,13 @@ enum class ThreadPriority : u32 {
 enum class ThreadPlacement : u32 {
     Default = 0,
     Background = 1,
+    Efficiency = 2,
 };
 
 void SetCurrentThreadPriority(ThreadPriority new_priority);
 void SetCurrentThreadName(const char* name);
 void SetCurrentThreadToPerformanceCores();
 void SetCurrentThreadToEfficiencyCores();
+void RefreshThreadPolicies();
 
 } // namespace Common

src/common/thread_worker.h

@@ -42,8 +42,10 @@ public:
         : workers_queued{num_workers}, thread_name{std::move(name)} {
         const auto lambda = [this, func, placement](std::stop_token stop_token) {
             Common::SetCurrentThreadName(thread_name.c_str());
-            if (placement == ThreadPlacement::Background) {
+            if (placement != ThreadPlacement::Default) {
                 Common::SetCurrentThreadPriority(ThreadPriority::Low);
+            }
+            if (placement == ThreadPlacement::Efficiency) {
                 Common::SetCurrentThreadToEfficiencyCores();
             }
             {

src/core/core_timing.cpp

@@ -58,7 +58,8 @@ void CoreTiming::Initialize(std::function<void()>&& on_thread_init_) {
     if (is_multicore) {
         timer_thread = std::jthread([this](std::stop_token stop_token) {
             Common::SetCurrentThreadName("HostTiming");
-            Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
+            Common::SetCurrentThreadPriority(Common::ThreadPriority::VeryHigh);
+            Common::SetCurrentThreadToPerformanceCores();
             on_thread_init();
             has_started = true;
 

src/core/device_memory.cpp

@@ -12,9 +12,18 @@ constexpr size_t VirtualReserveSize = 1ULL << 38;
 constexpr size_t VirtualReserveSize = 1ULL << 39;
 #endif
 
+namespace {
+size_t ApplicationPoolOffset() {
+    using Init = Kernel::Board::Nintendo::Nx::KSystemControl::Init;
+    const size_t dram_size = Init::GetIntendedMemorySize();
+    const size_t application_pool_size = Init::GetApplicationPoolSize();
+    return dram_size > application_pool_size ? dram_size - application_pool_size : 0;
+}
+}
+
 DeviceMemory::DeviceMemory()
     : buffer{Kernel::Board::Nintendo::Nx::KSystemControl::Init::GetIntendedMemorySize(),
-             VirtualReserveSize} {}
+             VirtualReserveSize, ApplicationPoolOffset()} {}
 
 DeviceMemory::~DeviceMemory() = default;
 

src/core/device_memory_manager.h

@@ -117,6 +117,14 @@ public:
         return ahb_window_size;
     }
 
+    size_t GetBackingHardwareBufferBase() const noexcept {
+        return ahb_base;
+    }
+
+    bool IsBackingShared() const noexcept {
+        return backing_is_shared;
+    }
+
     PAddr GetPhysicalRawAddressFromDAddr(DAddr address) const {
         PAddr subbits = PAddr(address & page_mask);
         auto paddr = tracked_entries[(address >> page_bits)].compressed_physical_ptr;
@@ -200,6 +208,8 @@ private:
     const size_t physical_size;
     const std::span<AHardwareBuffer* const> ahb_windows;
     const size_t ahb_window_size;
+    const size_t ahb_base;
+    const bool backing_is_shared;
     DeviceInterface* device_inter;
 
     struct TrackedEntry {

src/core/device_memory_manager.inc

@@ -174,6 +174,8 @@ DeviceMemoryManager<Traits>::DeviceMemoryManager(const DeviceMemory& device_memo
     , physical_size{device_memory_.buffer.BackingSize()}
     , ahb_windows{device_memory_.buffer.BackingHardwareBuffers()}
     , ahb_window_size{device_memory_.buffer.BackingHardwareBufferWindowSize()}
+    , ahb_base{device_memory_.buffer.BackingHardwareBufferBase()}
+    , backing_is_shared{device_memory_.buffer.IsBackingShared()}
     , device_inter{nullptr}
     , compressed_device_addr(1ULL << ((Settings::values.memory_layout_mode.GetValue() == Settings::MemoryLayout::Memory_4Gb ? physical_min_bits : physical_max_bits) - Memory::YUZU_PAGEBITS))
     , tracked_entries(device_as_size >> Memory::YUZU_PAGEBITS)

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

@@ -375,39 +375,42 @@ NvResult nvhost_as_gpu::MapBufferEx(IoctlMapBufferEx& params) {
         mapping_map.insert_or_assign(params.offset, Mapping(params.handle, device_address, params.offset, size, false, big_page, false));
     }
 
-    map_buffer_offsets.insert(params.offset);
-
     return NvResult::Success;
 }
 
 NvResult nvhost_as_gpu::UnmapBuffer(IoctlUnmapBuffer& params) {
+    LOG_DEBUG(Service_NVDRV, "called, offset={:#X}", params.offset);
+
     std::scoped_lock lock(mutex);
-    if (auto const offset_it = map_buffer_offsets.find(params.offset); offset_it != map_buffer_offsets.end()) {
-        LOG_DEBUG(Service_NVDRV, "called, offset={:#X}", params.offset);
-        if (!vm.initialised) {
-            return NvResult::BadValue;
-        }
 
-        auto const it = mapping_map.find(params.offset);
-        auto const mapping = it->second;
-        if (!mapping.fixed) {
-            auto& allocator{mapping.big_page ? *vm.big_page_allocator : *vm.small_page_allocator};
-            u32 page_size_bits{mapping.big_page ? vm.big_page_size_bits : VM::PAGE_SIZE_BITS};
-            allocator.Free(u32(mapping.offset >> page_size_bits), u32(mapping.size >> page_size_bits));
-        }
-
-        // Sparse mappings shouldn't be fully unmapped, just returned to their sparse state
-        // Only FreeSpace can unmap them fully
-        if (mapping.sparse_alloc) {
-            gmmu->MapSparse(params.offset, mapping.size, mapping.big_page);
-        } else {
-            gmmu->Unmap(params.offset, mapping.size);
-        }
-
-        nvmap.UnpinHandle(mapping.handle);
-        mapping_map.erase(params.offset);
-        map_buffer_offsets.erase(params.offset);
+    if (!vm.initialised) {
+        return NvResult::BadValue;
     }
+
+    auto const it = mapping_map.find(params.offset);
+    if (it == mapping_map.end()) {
+        LOG_WARNING(Service_NVDRV, "Couldn't find region to unmap at {:#X}", params.offset);
+        return NvResult::Success;
+    }
+
+    auto const mapping = it->second;
+    if (!mapping.fixed) {
+        auto& allocator{mapping.big_page ? *vm.big_page_allocator : *vm.small_page_allocator};
+        u32 page_size_bits{mapping.big_page ? vm.big_page_size_bits : VM::PAGE_SIZE_BITS};
+        allocator.Free(u32(mapping.offset >> page_size_bits), u32(mapping.size >> page_size_bits));
+    }
+
+    // Sparse mappings shouldn't be fully unmapped, just returned to their sparse state
+    // Only FreeSpace can unmap them fully
+    if (mapping.sparse_alloc) {
+        gmmu->MapSparse(params.offset, mapping.size, mapping.big_page);
+    } else {
+        gmmu->Unmap(params.offset, mapping.size);
+    }
+
+    nvmap.UnpinHandle(mapping.handle);
+    mapping_map.erase(it);
+
     return NvResult::Success;
 }
 

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

@@ -13,7 +13,6 @@
 #include <memory>
 #include <mutex>
 #include <optional>
-#include <ankerl/unordered_dense.h>
 #include <vector>
 
 #include "common/address_space.h"
@@ -113,8 +112,6 @@ private:
     };
     static_assert(sizeof(IoctlRemapEntry) == 20, "IoctlRemapEntry is incorrect size");
 
-    ankerl::unordered_dense::set<s64_le> map_buffer_offsets{};
-
     struct IoctlMapBufferEx {
         MappingFlags flags{}; // bit0: fixed_offset, bit2: cacheable
         u32_le kind{};        // -1 is default

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

@@ -4,6 +4,7 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include <algorithm>
 #include <cstring>
 #include "common/assert.h"
 #include "common/logging.h"
@@ -264,7 +265,7 @@ NvResult nvhost_ctrl_gpu::ZCullGetInfo(IoctlNvgpuGpuZcullGetInfoArgs& params) {
 }
 
 NvResult nvhost_ctrl_gpu::ZBCSetTable(IoctlZbcSetTable& params) {
-    if (params.type > supported_types) {
+    if (params.type == 0 || params.type > supported_types) {
         LOG_ERROR(Service_NVDRV, "ZBCSetTable: invalid type {:#X}", params.type);
         return NvResult::BadParameter;
     }
@@ -279,42 +280,61 @@ NvResult nvhost_ctrl_gpu::ZBCSetTable(IoctlZbcSetTable& params) {
             color_entry.format = params.format;
             color_entry.ref_cnt = 1u;
 
-            auto color_it = std::ranges::find_if(zbc_colors,
-                                                 [&](const ZbcColorEntry& color_in_question) {
-                                                     return color_entry.format == color_in_question.format &&
-                                                            color_entry.color_ds == color_in_question.color_ds &&
-                                                            color_entry.color_l2 == color_in_question.color_l2;
-                                                 });
+            const auto color_end = zbc_colors.begin() + zbc_used_color_entries;
+            auto color_it = std::find_if(zbc_colors.begin(), color_end,
+                                         [&](const ZbcColorEntry& color_in_question) {
+                                             return color_entry.format == color_in_question.format &&
+                                                    color_entry.color_ds == color_in_question.color_ds &&
+                                                    color_entry.color_l2 == color_in_question.color_l2;
+                                         });
 
-            if (color_it != zbc_colors.end()) {
+            if (color_it != color_end) {
                 ++color_it->ref_cnt;
                 LOG_DEBUG(Service_NVDRV, "ZBCSetTable: reused color entry fmt={:#X}, ref_cnt={:#X}",
                           params.format, color_it->ref_cnt);
-            } else {
-                zbc_colors.push_back(color_entry);
-                LOG_DEBUG(Service_NVDRV, "ZBCSetTable: added color entry fmt={:#X}, index={:#X}",
-                          params.format, zbc_colors.size() - 1);
+                break;
             }
+
+            if (zbc_used_color_entries >= zbc_table_size) {
+                LOG_WARNING(Service_NVDRV, "ZBCSetTable: color table is full, fmt={:#X}",
+                            params.format);
+                return NvResult::InsufficientMemory;
+            }
+
+            zbc_colors[zbc_used_color_entries] = color_entry;
+            LOG_DEBUG(Service_NVDRV, "ZBCSetTable: added color entry fmt={:#X}, index={:#X}",
+                      params.format, zbc_used_color_entries);
+            ++zbc_used_color_entries;
             break;
         }
         case ZBCTypes::depth: {
             ZbcDepthEntry depth_entry{params.depth, params.format, 1u};
 
-            auto depth_it = std::ranges::find_if(zbc_depths,
-                                                 [&](const ZbcDepthEntry& depth_entry_in_question) {
-                                                     return depth_entry.format == depth_entry_in_question.format &&
-                                                            depth_entry.depth == depth_entry_in_question.depth;
-                                                 });
+            const auto depth_end = zbc_depths.begin() + zbc_used_depth_entries;
+            auto depth_it = std::find_if(zbc_depths.begin(), depth_end,
+                                         [&](const ZbcDepthEntry& depth_entry_in_question) {
+                                             return depth_entry.format == depth_entry_in_question.format &&
+                                                    depth_entry.depth == depth_entry_in_question.depth;
+                                         });
 
-            if (depth_it != zbc_depths.end()) {
+            if (depth_it != depth_end) {
                 ++depth_it->ref_cnt;
                 LOG_DEBUG(Service_NVDRV, "ZBCSetTable: reused depth entry fmt={:#X}, ref_cnt={:#X}",
                           depth_entry.format, depth_it->ref_cnt);
-            } else {
-                zbc_depths.push_back(depth_entry);
-                LOG_DEBUG(Service_NVDRV, "ZBCSetTable: added depth entry fmt={:#X}, index={:#X}",
-                          depth_entry.format, zbc_depths.size() - 1);
+                break;
             }
+
+            if (zbc_used_depth_entries >= zbc_table_size) {
+                LOG_WARNING(Service_NVDRV, "ZBCSetTable: depth table is full, fmt={:#X}",
+                            depth_entry.format);
+                return NvResult::InsufficientMemory;
+            }
+
+            zbc_depths[zbc_used_depth_entries] = depth_entry;
+            LOG_DEBUG(Service_NVDRV, "ZBCSetTable: added depth entry fmt={:#X}, index={:#X}",
+                      depth_entry.format, zbc_used_depth_entries);
+            ++zbc_used_depth_entries;
+            break;
         }
     }
 
@@ -329,35 +349,34 @@ NvResult nvhost_ctrl_gpu::ZBCQueryTable(IoctlZbcQueryTable& params) {
 
     std::scoped_lock lk(zbc_mutex);
 
+    if (params.type == 0) {
+        params.index_size = zbc_table_size;
+        return NvResult::Success;
+    }
+
+    if (params.index_size >= zbc_table_size) {
+        LOG_ERROR(Service_NVDRV, "ZBCQueryTable: invalid index {:#X}", params.index_size);
+        return NvResult::BadParameter;
+    }
+
     switch (static_cast<ZBCTypes>(params.type)) {
         case ZBCTypes::color: {
-            if (params.index_size >= zbc_colors.size()) {
-                LOG_ERROR(Service_NVDRV, "ZBCQueryTable: invalid color index {:#X}", params.index_size);
-                return NvResult::BadParameter;
-            }
-
             const auto& colors = zbc_colors[params.index_size];
             std::copy_n(colors.color_ds.begin(), colors.color_ds.size(), std::begin(params.color_ds));
             std::copy_n(colors.color_l2.begin(), colors.color_l2.size(), std::begin(params.color_l2));
             params.depth = 0;
             params.ref_cnt = colors.ref_cnt;
             params.format = colors.format;
-            params.index_size = static_cast<u32>(zbc_colors.size());
             break;
         }
         case ZBCTypes::depth: {
-            if (params.index_size >= zbc_depths.size()) {
-                LOG_ERROR(Service_NVDRV, "ZBCQueryTable: invalid depth index {:#X}", params.index_size);
-                return NvResult::BadParameter;
-            }
-
             const auto& depth_entry = zbc_depths[params.index_size];
             std::fill(std::begin(params.color_ds), std::end(params.color_ds), 0);
             std::fill(std::begin(params.color_l2), std::end(params.color_l2), 0);
             params.depth = depth_entry.depth;
             params.ref_cnt = depth_entry.ref_cnt;
             params.format = depth_entry.format;
-            params.index_size = static_cast<u32>(zbc_depths.size());
+            break;
         }
     }
 

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

@@ -6,7 +6,7 @@
 
 #pragma once
 
-#include <vector>
+#include <array>
 
 #include "common/common_funcs.h"
 #include "common/common_types.h"
@@ -212,9 +212,13 @@ private:
     Kernel::KEvent* unknown_event;
 
     // ZBC Tables
+    static constexpr u32 zbc_table_size = 15u;
+
     std::mutex zbc_mutex{};
-    std::vector<ZbcColorEntry> zbc_colors{};
-    std::vector<ZbcDepthEntry> zbc_depths{};
+    std::array<ZbcColorEntry, zbc_table_size> zbc_colors{};
+    std::array<ZbcDepthEntry, zbc_table_size> zbc_depths{};
+    u32 zbc_used_color_entries{};
+    u32 zbc_used_depth_entries{};
     const u32 supported_types = 2u;
 };
 

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

@@ -174,7 +174,9 @@ NvResult nvhost_gpu::SetChannelPriority(IoctlChannelSetPriority& params) {
     case ChannelPriority::Low: channel_timeslice = 1300; break;
     case ChannelPriority::Medium: channel_timeslice = 2600; break;
     case ChannelPriority::High: channel_timeslice = 5200; break;
-    default : return NvResult::BadParameter;
+    default:
+        LOG_WARNING(Service_NVDRV, "unknown channel priority {:#X}", channel_priority);
+        break;
     }
 
     return NvResult::Success;
@@ -278,18 +280,20 @@ NvResult nvhost_gpu::AllocateObjectContext(IoctlAllocObjCtx& params) {
         params.flags = allowed_mask;
     }
 
-    s32_le ctx_class_number_index = 
+    params.obj_id = 0;
+
+    s32_le ctx_class_number_index =
         GetObjectContextClassNumberIndex(static_cast<CtxClasses>(params.class_num));
     if (ctx_class_number_index < 0) {
-        LOG_ERROR(Service_NVDRV, "Invalid class number for object context: {:#X}",
-                  params.class_num);
-        return NvResult::BadParameter;
+        LOG_WARNING(Service_NVDRV, "Untracked class number for object context: {:#X}",
+                    params.class_num);
+        return NvResult::Success;
     }
 
     if (ctxObjs[ctx_class_number_index].has_value()) {
-        LOG_WARNING(Service_NVDRV, "Object context for class {:#X} already allocated on this channel",
-                    params.class_num);
-        return NvResult::AlreadyAllocated;
+        LOG_DEBUG(Service_NVDRV, "Object context for class {:#X} already allocated on this channel",
+                  params.class_num);
+        return NvResult::Success;
     }
 
     // Defer actual hardware context binding until channel is initialized.
@@ -435,10 +439,6 @@ NvResult nvhost_gpu::ChannelSetTimeout(IoctlChannelSetTimeout& params) {
 NvResult nvhost_gpu::ChannelSetTimeslice(IoctlSetTimeslice& params) {
     LOG_INFO(Service_NVDRV, "called, timeslice={:#X}", params.timeslice);
 
-    if (params.timeslice < 1000 || params.timeslice > 5000) {
-        return NvResult::BadParameter;
-    }
-
     channel_timeslice = params.timeslice;
 
     return NvResult::Success;

src/core/hle/service/nvnflinger/buffer_queue_core.cpp

@@ -20,33 +20,23 @@ BufferQueueCore::~BufferQueueCore() = default;
 void BufferQueueCore::PushHistory(u64 frame_number, s64 queue_time, s64 presentation_time, BufferState state) {
     std::lock_guard lk(buffer_history_mutex);
 
-    auto it = buffer_history_map.find(frame_number);
-    if (it != buffer_history_map.end()) {
-        it->second.state = state;
-        return;
-    }
-
-    buffer_history_map.emplace(frame_number, BufferHistoryInfo{
+    buffer_history_pos = (buffer_history_pos + 1) % BUFFER_HISTORY_SIZE;
+    buffer_history[buffer_history_pos] = BufferHistoryInfo{
         frame_number,
         queue_time,
         presentation_time,
         state
-    });
-    buffer_history_order.push_back(frame_number);
-
-    if (buffer_history_order.size() > BUFFER_HISTORY_SIZE) {
-        u64 oldest_frame = buffer_history_order.front();
-        buffer_history_order.pop_front();
-        buffer_history_map.erase(oldest_frame);
-    }
+    };
 }
 
 void BufferQueueCore::UpdateHistory(u64 frame_number, BufferState state) {
     std::lock_guard lk(buffer_history_mutex);
 
-    auto it = buffer_history_map.find(frame_number);
-    if (it != buffer_history_map.end()) {
-        it->second.state = state;
+    for (auto& entry : buffer_history) {
+        if (entry.frame_number == frame_number) {
+            entry.state = state;
+            return;
+        }
     }
 }
 

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

@@ -9,14 +9,13 @@
 
 #pragma once
 
+#include <array>
 #include <condition_variable>
-#include <deque>
 #include <list>
 #include <memory>
 #include <mutex>
 #include <set>
 #include <vector>
-#include <unordered_map>
 #include <algorithm>
 
 #include "core/hle/service/nvnflinger/buffer_item.h"
@@ -28,12 +27,15 @@
 
 namespace Service::android {
 
+#pragma pack(push, 1)
 struct BufferHistoryInfo {
-    u64 frame_number{};
-    s64 queue_time{};
-    s64 presentation_time{};
-    BufferState state{};
+    u64 frame_number;
+    s64 queue_time;
+    s64 presentation_time;
+    BufferState state;
 };
+#pragma pack(pop)
+static_assert(sizeof(BufferHistoryInfo) == 0x1C, "BufferHistoryInfo must be 28 bytes");
 
 class IConsumerListener;
 class IProducerListener;
@@ -88,9 +90,9 @@ private:
     bool buffer_has_been_queued{};
     u64 frame_counter{};
 
-    std::unordered_map<u64, BufferHistoryInfo> buffer_history_map{};
+    std::array<BufferHistoryInfo, BUFFER_HISTORY_SIZE> buffer_history{};
+    u32 buffer_history_pos{BUFFER_HISTORY_SIZE - 1};
     mutable std::mutex buffer_history_mutex{};
-    std::deque<u64> buffer_history_order;
 
     u32 transform_hint{};
     bool is_allocating{};

src/core/hle/service/nvnflinger/buffer_queue_producer.cpp

@@ -507,6 +507,8 @@ Status BufferQueueProducer::QueueBuffer(s32 slot, const QueueBufferInput& input,
 
         sticky_transform = sticky_transform_;
 
+        const bool track_history = Settings::values.enable_buffer_history.GetValue();
+
         if (core->queue.empty()) {
             core->queue.push_back(item);
             listener_available = core->consumer_listener;
@@ -514,7 +516,7 @@ Status BufferQueueProducer::QueueBuffer(s32 slot, const QueueBufferInput& input,
             auto front = core->queue.begin();
             if (front->is_droppable && core->StillTracking(*front)) {
                 slots[front->slot].buffer_state = BufferState::Free;
-                if (Settings::values.enable_buffer_history.GetValue()) {
+                if (track_history) {
                     core->UpdateHistory(front->frame_number, BufferState::Free);
                 }
                 slots[front->slot].frame_number = 0;
@@ -529,7 +531,7 @@ Status BufferQueueProducer::QueueBuffer(s32 slot, const QueueBufferInput& input,
             }
         }
 
-        if (Settings::values.enable_buffer_history.GetValue()) {
+        if (track_history) {
             core->PushHistory(core->frame_counter, slots[slot].queue_time, slots[slot].presentation_time, BufferState::Queued);
         }
 
@@ -902,26 +904,31 @@ void BufferQueueProducer::Transact(u32 code, std::span<const u8> parcel_data,
 
         const s32 request = parcel_in.Read<s32>();
         if (request <= 0) {
-            parcel_out.Write(Status::BadValue);
+            status = Status::BadValue;
             parcel_out.Write<s32>(0);
             break;
         }
 
-        std::vector<BufferHistoryInfo> snapshot;
+        constexpr u32 history_size = BufferQueueCore::BUFFER_HISTORY_SIZE;
+        std::array<BufferHistoryInfo, history_size> snapshot{};
+        s32 count{};
 
         {
             std::scoped_lock lk(core->buffer_history_mutex);
-            for (auto& [frame, info] : core->buffer_history_map) {
-                snapshot.push_back(info);
+
+            const u32 newest = core->buffer_history_pos;
+            for (u32 i = 0; i < history_size; ++i) {
+                const auto& entry = core->buffer_history[(newest + history_size - i) % history_size];
+                if (entry.frame_number == 0) {
+                    break;
+                }
+
+                snapshot[count] = entry;
+                ++count;
             }
         }
 
-        std::sort(snapshot.begin(), snapshot.end(), [](auto& a, auto& b){
-            return a.frame_number > b.frame_number;
-        });
-
-        const s32 limit = std::min(request, (s32)snapshot.size());
-        parcel_out.Write(Status::NoError);
+        const s32 limit = (std::min)(request, count);
         parcel_out.Write<s32>(limit);
         for (s32 i = 0; i < limit; ++i) {
             parcel_out.Write(snapshot[i]);

src/core/hle/service/vi/conductor.cpp

@@ -5,6 +5,7 @@
 // SPDX-License-Identifier: GPL-2.0-or-later
 
 #include "common/settings.h"
+#include "common/thread.h"
 #include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/service/vi/conductor.h"
@@ -76,6 +77,7 @@ void Conductor::ProcessVsync() {
 
 void Conductor::VsyncThread(std::stop_token token) {
     Common::SetCurrentThreadName("VSyncThread");
+    Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
 
     while (!token.stop_requested()) {
         m_signal.Wait();

src/shader_recompiler/frontend/maxwell/translate/impl/internal_stage_buffer_entry_read.cpp

@@ -17,28 +17,12 @@ enum class Mode : u64 {
     Attr,
 };
 
-enum class SZ : u64 {
-    U8,
-    U16,
-    U32,
-    F32
-};
-
 enum class Shift : u64 {
     Default,
     U16,
     B32,
 };
 
-IR::U32 scaleIndex(IR::IREmitter& ir, IR::U32 index, Shift shift) {
-    switch (shift) {
-        case Shift::Default: return index;
-        case Shift::U16: return ir.ShiftLeftLogical(index, ir.Imm32(1));
-        case Shift::B32: return ir.ShiftLeftLogical(index, ir.Imm32(2));
-        default: UNREACHABLE();
-    }
-}
-
 } // Anonymous namespace
 
 void TranslatorVisitor::ISBERD(u64 insn) {
@@ -53,7 +37,6 @@ void TranslatorVisitor::ISBERD(u64 insn) {
         BitField<31, 1, u64> skew;
         BitField<32, 1, u64> o;
         BitField<33, 2, Mode> mode;
-        BitField<36, 4, SZ> sz;
         BitField<47, 2, Shift> shift;
     } const isberd{insn};
 
@@ -63,31 +46,15 @@ void TranslatorVisitor::ISBERD(u64 insn) {
     if (isberd.o != 0) {
         throw NotImplementedException("ISBERD O");
     }
-    if (isberd.sz.Value() > SZ::F32) {
-        throw NotImplementedException("ISBERD SZ {}",
-                                      static_cast<u64>(isberd.sz.Value()));
-    }
-    if (isberd.shift.Value() > Shift::B32) {
-        throw NotImplementedException("ISBERD Shift {}",
-                                      static_cast<u64>(isberd.shift.Value()));
-    }
 
     switch (isberd.mode.Value()) {
     case Mode::Default:
         X(isberd.dest_reg.Value(), X(isberd.src_reg.Value()));
         return;
-    case Mode::Attr: {
-        IR::U32 offset{};
-        if (isberd.src_reg_num.Value() == 0xFF) {
-            offset = ir.Imm32(isberd.imm.Value());
-        } else {
-            const IR::U32 index{
-                scaleIndex(ir, X(isberd.src_reg.Value()), isberd.shift.Value())};
-            offset = ir.IAdd(index, ir.Imm32(isberd.imm.Value()));
-        }
-        X(isberd.dest_reg.Value(), ir.BitCast<IR::U32>(ir.GetAttributeIndexed(offset)));
+    case Mode::Attr:
+        LOG_DEBUG(Shader, "(STUBBED) ISBERD Mode Attr");
+        X(isberd.dest_reg.Value(), X(isberd.src_reg.Value()));
         return;
-    }
     default:
         throw NotImplementedException("ISBERD Mode {}",
                                       static_cast<u64>(isberd.mode.Value()));

src/video_core/buffer_cache/buffer_cache.h

@@ -92,6 +92,11 @@ u64 BufferCache<P>::ReclaimMemory(u64 target_bytes, bool allow_download) {
     return freed;
 }
 
+template <class P>
+void BufferCache<P>::ReclaimDeferredResources(u64 completed_sync_point) {
+    sentenced_buffers.Reclaim(completed_sync_point);
+}
+
 template <class P>
 void BufferCache<P>::EnsureHeadroom(bool allow_download) {
     if (reclaim_stalled) {
@@ -139,9 +144,9 @@ void BufferCache<P>::TickFrame() {
 
     usage_refresh_countdown = 0;
     reclaim_stalled = false;
+    ReclaimDeferredResources(runtime.CompletedSyncPoint());
     EnsureHeadroom(true);
     ++frame_tick;
-    sentenced_buffers.Reclaim(runtime.CompletedSyncPoint());
 
     for (auto& buffer : async_buffers_death_ring) {
         runtime.FreeDeferredStagingBuffer(buffer);
@@ -670,7 +675,11 @@ void BufferCache<P>::AccumulateFlushes() {
 
 template <class P>
 bool BufferCache<P>::ShouldWaitAsyncFlushes() const noexcept {
-    return (!async_buffers.empty() && async_buffers.front().has_value());
+    if (async_buffers.empty()) {
+        return false;
+    }
+    return async_buffers.front().has_value() ||
+           !pending_downloads.front().unified_copies.empty();
 }
 
 template <class P>
@@ -678,6 +687,7 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
     AccumulateFlushes();
 
     if (committed_gpu_modified_ranges.empty()) {
+        pending_downloads.emplace_back();
         async_buffers.emplace_back(std::optional<Async_Buffer>{});
         return;
     }
@@ -737,27 +747,83 @@ void BufferCache<P>::CommitAsyncFlushesHigh() {
     }
     committed_gpu_modified_ranges.clear();
     if (downloads.empty()) {
+        pending_downloads.emplace_back();
         async_buffers.emplace_back(std::optional<Async_Buffer>{});
         return;
     }
-    auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes, true);
-    boost::container::small_vector<BufferCopy, 4> normalized_copies;
-    runtime.PreCopyBarrier();
+
+    struct QueuedUnifiedCopy {
+        u64 window;
+        BufferId buffer_id;
+        boost::container::small_vector<BufferCopy, 16> copies;
+    };
+
+    AsyncDownloadBatch batch;
+    boost::container::small_vector<std::pair<BufferCopy, BufferId>, 16> staging_downloads;
+    boost::container::small_vector<QueuedUnifiedCopy, 4> unified_copy_queue;
+    boost::container::small_vector<u64, 4> window_ids;
+    UnifiedWindowGroups groups;
+    u64 staging_size_bytes = 0;
     for (auto& [copy, buffer_id] : downloads) {
-        copy.dst_offset += download_staging.offset;
-        const std::array copies{copy};
-        BufferCopy second_copy{copy};
         Buffer& buffer = slot_buffers[buffer_id];
-        second_copy.src_offset = static_cast<size_t>(buffer.CpuAddr()) + copy.src_offset;
-        const DAddr orig_device_addr = static_cast<DAddr>(second_copy.src_offset);
+        const DAddr orig_device_addr = buffer.CpuAddr() + copy.src_offset;
+        bool unified = false;
+        if constexpr (USE_UNIFIED_MEMORY) {
+            if (runtime.HasUnifiedMemory()) {
+                window_ids.clear();
+                groups.clear();
+                unified = ResolveUnifiedWindows(orig_device_addr, copy.src_offset, copy.size,
+                                                window_ids, groups);
+            }
+        }
+        BufferCopy record{copy};
+        record.src_offset = static_cast<size_t>(orig_device_addr);
+        if (unified) {
+            async_downloads.Add(orig_device_addr, copy.size);
+            buffer.MarkUsage(copy.src_offset, copy.size);
+            for (size_t i = 0; i < window_ids.size(); ++i) {
+                unified_copy_queue.push_back(
+                    QueuedUnifiedCopy{window_ids[i], buffer_id, std::move(groups[i])});
+            }
+            batch.unified_copies.push_back(record);
+            continue;
+        }
+        copy.dst_offset = staging_size_bytes;
+        constexpr u64 align = 64ULL;
+        staging_size_bytes += (copy.size + align - 1) & ~(align - 1ULL);
+        staging_downloads.push_back({copy, buffer_id});
+    }
+
+    std::optional<Async_Buffer> download_staging;
+    if (!staging_downloads.empty()) {
+        download_staging = runtime.DownloadStagingBuffer(staging_size_bytes, true);
+    }
+    runtime.PreCopyBarrier();
+    for (auto& [copy, buffer_id] : staging_downloads) {
+        copy.dst_offset += download_staging->offset;
+        const std::array copies{copy};
+        Buffer& buffer = slot_buffers[buffer_id];
+        BufferCopy record{copy};
+        record.src_offset = static_cast<size_t>(buffer.CpuAddr()) + copy.src_offset;
+        const DAddr orig_device_addr = static_cast<DAddr>(record.src_offset);
         async_downloads.Add(orig_device_addr, copy.size);
         buffer.MarkUsage(copy.src_offset, copy.size);
-        runtime.CopyBuffer(download_staging.buffer, buffer, copies, false);
-        normalized_copies.push_back(second_copy);
+        runtime.CopyBuffer(download_staging->buffer, buffer, copies, false);
+        batch.staging_copies.push_back(record);
+    }
+    if constexpr (USE_UNIFIED_MEMORY) {
+        for (const auto& queued : unified_copy_queue) {
+            const std::span<const BufferCopy> group_span(queued.copies.data(),
+                                                         queued.copies.size());
+            runtime.CopyToUnifiedMemory(queued.window, slot_buffers[queued.buffer_id], group_span);
+        }
+        if (!unified_copy_queue.empty()) {
+            runtime.UnifiedMemoryHostBarrier();
+        }
     }
     runtime.PostCopyBarrier();
-    pending_downloads.emplace_back(std::move(normalized_copies));
-    async_buffers.emplace_back(download_staging);
+    pending_downloads.emplace_back(std::move(batch));
+    async_buffers.emplace_back(std::move(download_staging));
 }
 
 template <class P>
@@ -783,27 +849,32 @@ void BufferCache<P>::PopAsyncBuffers() {
         if (async_buffers.empty()) {
             return;
         }
-        if (!async_buffers.front().has_value()) {
-            async_buffers.pop_front();
-            return;
-        }
-        auto& downloads = pending_downloads.front();
+        auto& batch = pending_downloads.front();
         auto& async_buffer = async_buffers.front();
-        const u8* base = async_buffer->mapped_span.data();
-        const size_t base_offset = async_buffer->offset;
-        for (const auto& copy : downloads) {
+        if (async_buffer.has_value()) {
+            const u8* base = async_buffer->mapped_span.data();
+            const size_t base_offset = async_buffer->offset;
+            for (const auto& copy : batch.staging_copies) {
+                const DAddr device_addr = static_cast<DAddr>(copy.src_offset);
+                const u64 dst_offset = copy.dst_offset - base_offset;
+                const u8* read_mapped_memory = base + dst_offset;
+                async_downloads.ForEachInRange(
+                    device_addr, copy.size, [&](DAddr start, DAddr end, s32) {
+                        writebacks.push_back(
+                            {start, &read_mapped_memory[start - device_addr], end - start});
+                    });
+                async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) {
+                    gpu_modified_ranges.Subtract(start, end - start);
+                });
+            }
+            async_buffers_death_ring.emplace_back(*async_buffer);
+        }
+        for (const auto& copy : batch.unified_copies) {
             const DAddr device_addr = static_cast<DAddr>(copy.src_offset);
-            const u64 dst_offset = copy.dst_offset - base_offset;
-            const u8* read_mapped_memory = base + dst_offset;
-            async_downloads.ForEachInRange(device_addr, copy.size, [&](DAddr start, DAddr end, s32) {
-                writebacks.push_back(
-                    {start, &read_mapped_memory[start - device_addr], end - start});
-            });
             async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) {
                 gpu_modified_ranges.Subtract(start, end - start);
             });
         }
-        async_buffers_death_ring.emplace_back(*async_buffer);
         async_buffers.pop_front();
         pending_downloads.pop_front();
     }
@@ -1815,17 +1886,18 @@ void BufferCache<P>::ImmediateUploadMemory([[maybe_unused]] Buffer& buffer,
 }
 
 template <class P>
-bool BufferCache<P>::TryUnifiedDownloadMemory([[maybe_unused]] Buffer& buffer,
-                                              [[maybe_unused]] std::span<BufferCopy> copies) {
+bool BufferCache<P>::ResolveUnifiedWindows(
+    [[maybe_unused]] DAddr device_addr, [[maybe_unused]] u64 buffer_offset,
+    [[maybe_unused]] u64 size, [[maybe_unused]] boost::container::small_vector<u64, 4>& window_ids,
+    [[maybe_unused]] UnifiedWindowGroups& groups) {
     if constexpr (USE_UNIFIED_MEMORY) {
         const u8* const physical_base = device_memory.GetPhysicalBase();
+        const u64 unified_base = runtime.UnifiedMemoryBase();
         const u64 unified_size = runtime.UnifiedMemorySize();
         const u64 window_size = runtime.UnifiedMemoryWindowSize();
         if (window_size == 0) {
             return false;
         }
-        boost::container::small_vector<u64, 4> window_ids;
-        boost::container::small_vector<boost::container::small_vector<BufferCopy, 16>, 4> groups;
         const auto group_for = [&](u64 window) -> boost::container::small_vector<BufferCopy, 16>& {
             for (size_t i = 0; i < window_ids.size(); ++i) {
                 if (window_ids[i] == window) {
@@ -1836,51 +1908,68 @@ bool BufferCache<P>::TryUnifiedDownloadMemory([[maybe_unused]] Buffer& buffer,
             groups.emplace_back();
             return groups.back();
         };
+        u64 downloaded = 0;
+        while (downloaded < size) {
+            const DAddr page_addr = device_addr + downloaded;
+            const u8* const ptr = device_memory.GetPointer<u8>(page_addr);
+            if (ptr == nullptr) {
+                return false;
+            }
+            const u64 page_offset = page_addr & Core::DEVICE_PAGEMASK;
+            u64 chunk = (std::min)(size - downloaded,
+                                   static_cast<u64>(Core::DEVICE_PAGESIZE) - page_offset);
+            const u64 phys_offset = static_cast<u64>(ptr - physical_base);
+            if (phys_offset < unified_base || phys_offset - unified_base + chunk > unified_size) {
+                return false;
+            }
+            const u64 relative = phys_offset - unified_base;
+            const u64 window = relative / window_size;
+            const u64 local_offset = relative % window_size;
+            chunk = (std::min)(chunk, window_size - local_offset);
+            auto& group = group_for(window);
+            if (!group.empty()) {
+                BufferCopy& last = group.back();
+                if (last.src_offset + last.size == buffer_offset + downloaded &&
+                    last.dst_offset + last.size == local_offset) {
+                    last.size += chunk;
+                    downloaded += chunk;
+                    continue;
+                }
+            }
+            group.push_back(BufferCopy{
+                .src_offset = buffer_offset + downloaded,
+                .dst_offset = local_offset,
+                .size = chunk,
+            });
+            downloaded += chunk;
+        }
+        return true;
+    } else {
+        return false;
+    }
+}
+
+template <class P>
+bool BufferCache<P>::TryUnifiedDownloadMemory([[maybe_unused]] Buffer& buffer,
+                                              [[maybe_unused]] std::span<BufferCopy> copies) {
+    if constexpr (USE_UNIFIED_MEMORY) {
+        boost::container::small_vector<u64, 4> window_ids;
+        UnifiedWindowGroups groups;
         for (const BufferCopy& copy : copies) {
-            const DAddr device_addr = buffer.CpuAddr() + copy.src_offset;
-            u64 downloaded = 0;
-            while (downloaded < copy.size) {
-                const DAddr page_addr = device_addr + downloaded;
-                const u8* const ptr = device_memory.GetPointer<u8>(page_addr);
-                if (ptr == nullptr) {
-                    return false;
-                }
-                const u64 page_offset = page_addr & Core::DEVICE_PAGEMASK;
-                u64 chunk = (std::min)(copy.size - downloaded,
-                                       static_cast<u64>(Core::DEVICE_PAGESIZE) - page_offset);
-                const u64 phys_offset = static_cast<u64>(ptr - physical_base);
-                if (phys_offset + chunk > unified_size) {
-                    return false;
-                }
-                const u64 window = phys_offset / window_size;
-                const u64 local_offset = phys_offset % window_size;
-                chunk = (std::min)(chunk, window_size - local_offset);
-                auto& group = group_for(window);
-                if (!group.empty()) {
-                    BufferCopy& last = group.back();
-                    if (last.src_offset + last.size == copy.src_offset + downloaded &&
-                        last.dst_offset + last.size == local_offset) {
-                        last.size += chunk;
-                        downloaded += chunk;
-                        continue;
-                    }
-                }
-                group.push_back(BufferCopy{
-                    .src_offset = copy.src_offset + downloaded,
-                    .dst_offset = local_offset,
-                    .size = chunk,
-                });
-                downloaded += chunk;
+            if (!ResolveUnifiedWindows(buffer.CpuAddr() + copy.src_offset, copy.src_offset,
+                                       copy.size, window_ids, groups)) {
+                return false;
             }
         }
         for (const BufferCopy& copy : copies) {
             buffer.MarkUsage(copy.src_offset, copy.size);
         }
+        runtime.PreCopyBarrier();
         for (size_t i = 0; i < window_ids.size(); ++i) {
-            const std::span<BufferCopy> group_span(groups[i].data(), groups[i].size());
-            runtime.CopyBuffer(runtime.UnifiedMemoryWindowBuffer(window_ids[i]), buffer,
-                               group_span, true);
+            const std::span<const BufferCopy> group_span(groups[i].data(), groups[i].size());
+            runtime.CopyToUnifiedMemory(window_ids[i], buffer, group_span);
         }
+        runtime.UnifiedMemoryHostBarrier();
         runtime.Finish();
         return true;
     } else {

src/video_core/buffer_cache/buffer_cache_base.h

@@ -221,6 +221,8 @@ public:
 
     u64 ReclaimMemory(u64 target_bytes, bool allow_download);
 
+    void ReclaimDeferredResources(u64 completed_sync_point);
+
     void WriteMemory(DAddr device_addr, u64 size);
 
     void CachedWriteMemory(DAddr device_addr, u64 size);
@@ -453,6 +455,13 @@ private:
 
     bool TryUnifiedDownloadMemory(Buffer& buffer, std::span<BufferCopy> copies);
 
+    using UnifiedWindowGroups =
+        boost::container::small_vector<boost::container::small_vector<BufferCopy, 16>, 4>;
+
+    bool ResolveUnifiedWindows(DAddr device_addr, u64 buffer_offset, u64 size,
+                               boost::container::small_vector<u64, 4>& window_ids,
+                               UnifiedWindowGroups& groups);
+
     void DownloadBufferMemory(Buffer& buffer_id);
 
     void DownloadBufferMemory(Buffer& buffer_id, DAddr device_addr, u64 size);
@@ -503,9 +512,14 @@ private:
     std::deque<Common::RangeSet<DAddr>> committed_gpu_modified_ranges;
 
     // Async Buffers
+    struct AsyncDownloadBatch {
+        boost::container::small_vector<BufferCopy, 4> staging_copies;
+        boost::container::small_vector<BufferCopy, 4> unified_copies;
+    };
+
     Common::OverlapRangeSet<DAddr> async_downloads;
     std::deque<std::optional<Async_Buffer>> async_buffers;
-    std::deque<boost::container::small_vector<BufferCopy, 4>> pending_downloads;
+    std::deque<AsyncDownloadBatch> pending_downloads;
     std::optional<Async_Buffer> current_buffer;
 
     std::deque<Async_Buffer> async_buffers_death_ring;

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -366,14 +366,91 @@ BufferCacheRuntime::BufferCacheRuntime(const Device& device_, MemoryAllocator& m
 
 void BufferCacheRuntime::TryEnableUnifiedMemory(void* base, size_t size,
                                                 std::span<AHardwareBuffer* const> hardware_buffers,
-                                                size_t hardware_buffer_window) {
-    unified_memory = std::make_unique<HostMemoryImport>(device, base, size, hardware_buffers,
-                                                        hardware_buffer_window);
+                                                size_t hardware_buffer_window,
+                                                size_t hardware_buffer_base) {
+    unified_memory = std::make_unique<HostMemoryImport>(
+        device, base, size, hardware_buffers, hardware_buffer_window, hardware_buffer_base);
     if (!unified_memory->IsValid()) {
         unified_memory.reset();
     }
 }
 
+void BufferCacheRuntime::CopyToUnifiedMemory(
+    size_t window_index, VkBuffer src_buffer,
+    std::span<const VideoCommon::BufferCopy> copies) {
+    if (!unified_memory || src_buffer == VK_NULL_HANDLE || copies.empty() ||
+        window_index >= unified_memory->GetWindowCount()) {
+        return;
+    }
+    const VkBuffer dst_buffer = unified_memory->GetWindowBuffer(window_index);
+    if (dst_buffer == VK_NULL_HANDLE) {
+        return;
+    }
+    VkDeviceSize covered_begin = std::numeric_limits<VkDeviceSize>::max();
+    VkDeviceSize covered_end = 0;
+    for (const VideoCommon::BufferCopy& copy : copies) {
+        covered_begin = (std::min)(covered_begin, static_cast<VkDeviceSize>(copy.dst_offset));
+        covered_end = (std::max)(covered_end,
+                                 static_cast<VkDeviceSize>(copy.dst_offset + copy.size));
+    }
+
+    boost::container::small_vector<VkBufferCopy, 8> vk_copies(copies.size());
+    std::ranges::transform(copies, vk_copies.begin(), MakeBufferCopy);
+
+    const bool foreign = unified_memory->NeedsForeignOwnershipTransfer();
+    const u32 queue_family = device.GetGraphicsFamily();
+
+    scheduler.RequestOutsideRenderPassOperationContext();
+    scheduler.Record([src_buffer, dst_buffer, vk_copies, foreign, queue_family, covered_begin,
+                      covered_end](vk::CommandBuffer cmdbuf) {
+        if (foreign) {
+            const VkBufferMemoryBarrier acquire{
+                .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = 0,
+                .dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+                .srcQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT,
+                .dstQueueFamilyIndex = queue_family,
+                .buffer = dst_buffer,
+                .offset = covered_begin,
+                .size = covered_end - covered_begin,
+            };
+            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+                                   VK_PIPELINE_STAGE_TRANSFER_BIT, 0, acquire);
+        }
+        cmdbuf.CopyBuffer(src_buffer, dst_buffer, VideoCommon::FixSmallVectorADL(vk_copies));
+        if (foreign) {
+            const VkBufferMemoryBarrier release{
+                .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
+                .pNext = nullptr,
+                .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+                .dstAccessMask = 0,
+                .srcQueueFamilyIndex = queue_family,
+                .dstQueueFamilyIndex = VK_QUEUE_FAMILY_FOREIGN_EXT,
+                .buffer = dst_buffer,
+                .offset = covered_begin,
+                .size = covered_end - covered_begin,
+            };
+            cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
+                                   VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, release);
+        }
+    });
+}
+
+void BufferCacheRuntime::UnifiedMemoryHostBarrier() {
+    static constexpr VkMemoryBarrier HOST_BARRIER{
+        .sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER,
+        .pNext = nullptr,
+        .srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT,
+        .dstAccessMask = VK_ACCESS_HOST_READ_BIT,
+    };
+    scheduler.RequestOutsideRenderPassOperationContext();
+    scheduler.Record([](vk::CommandBuffer cmdbuf) {
+        cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, 0,
+                               HOST_BARRIER);
+    });
+}
+
 StagingBufferRef BufferCacheRuntime::UploadStagingBuffer(size_t size) {
     return staging_pool.Request(size, MemoryUsage::Upload);
 }

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -101,7 +101,7 @@ public:
 
     void TryEnableUnifiedMemory(void* base, size_t size,
                                 std::span<AHardwareBuffer* const> hardware_buffers,
-                                size_t hardware_buffer_window);
+                                size_t hardware_buffer_window, size_t hardware_buffer_base);
 
     [[nodiscard]] bool HasUnifiedMemory() const noexcept {
         return unified_memory != nullptr && unified_memory->IsValid();
@@ -111,13 +111,18 @@ public:
         return unified_memory ? unified_memory->GetSize() : 0;
     }
 
+    [[nodiscard]] u64 UnifiedMemoryBase() const noexcept {
+        return unified_memory ? unified_memory->GetBaseOffset() : 0;
+    }
+
     [[nodiscard]] u64 UnifiedMemoryWindowSize() const noexcept {
         return unified_memory ? unified_memory->GetWindowSize() : 0;
     }
 
-    [[nodiscard]] VkBuffer UnifiedMemoryWindowBuffer(size_t index) const noexcept {
-        return unified_memory ? unified_memory->GetWindowBuffer(index) : VK_NULL_HANDLE;
-    }
+    void CopyToUnifiedMemory(size_t window_index, VkBuffer src_buffer,
+                             std::span<const VideoCommon::BufferCopy> copies);
+
+    void UnifiedMemoryHostBarrier();
 
     u64 CurrentTick();
 

src/video_core/renderer_vulkan/vk_compute_pass.cpp

@@ -959,7 +959,7 @@ bool BlockLinearUnswizzle2DPass::IsSupported(const VideoCommon::ImageInfo& info)
     if (info.type != VideoCommon::ImageType::e2D) {
         return false;
     }
-    if (info.resources.levels != 1) {
+    if (info.resources.levels != 1 || info.resources.layers != 1) {
         return false;
     }
     if (info.num_samples > 1) {

src/video_core/renderer_vulkan/vk_present_manager.cpp

@@ -266,6 +266,7 @@ void PresentManager::WaitPresent() {
 
 void PresentManager::PresentThread(std::stop_token token) {
     Common::SetCurrentThreadName("VulkanPresent");
+    Common::SetCurrentThreadPriority(Common::ThreadPriority::High);
     while (!token.stop_requested()) {
         std::unique_lock lock{queue_mutex};
         // Wait for presentation frames

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -239,24 +239,40 @@ RasterizerVulkan::RasterizerVulkan(Core::Frontend::EmuWindow& emu_window_, Tegra
       fence_manager(*this, gpu, texture_cache, buffer_cache, query_cache, device, scheduler),
       wfi_event(device.GetLogical().CreateEvent()) {
     scheduler.SetQueryCache(query_cache);
-    if (Settings::values.use_unified_memory.GetValue()) {
+    if (Settings::values.use_unified_memory.GetValue() && device_memory.IsBackingShared()) {
         buffer_cache_runtime.TryEnableUnifiedMemory(
             device_memory.GetPhysicalBase(), device_memory.GetPhysicalSize(),
             device_memory.GetBackingHardwareBuffers(),
-            device_memory.GetBackingHardwareBufferWindowSize());
+            device_memory.GetBackingHardwareBufferWindowSize(),
+            device_memory.GetBackingHardwareBufferBase());
     }
     memory_allocator.SetReclaimCallback([this](u64 bytes) -> u64 {
-        u64 freed = staging_pool.ReclaimMemory(bytes);
-        if (freed < bytes) {
-            freed += texture_cache.ReclaimMemory(bytes - freed, false);
-        }
-        if (freed < bytes) {
-            freed += buffer_cache.ReclaimMemory(bytes - freed, false);
-        }
         auto& master_semaphore = scheduler.GetMasterSemaphore();
+        const u64 usage_before = device.GetMemoryBudgetInfo().allocation_bytes;
         master_semaphore.Refresh();
-        vk::TickDeletionQueue(master_semaphore.KnownGpuTick());
-        return freed;
+        const u64 completed = master_semaphore.KnownGpuTick();
+        texture_cache.ReclaimDeferredResources(completed);
+        buffer_cache.ReclaimDeferredResources(completed);
+        vk::TickDeletionQueue(completed);
+        const u64 usage_after = device.GetMemoryBudgetInfo().allocation_bytes;
+        const u64 drained = usage_before > usage_after ? usage_before - usage_after : 0;
+        if (drained >= bytes) {
+            return drained;
+        }
+        const u64 remaining = bytes - drained;
+        u64 evicted = staging_pool.ReclaimMemory(remaining);
+        if (evicted < remaining) {
+            evicted += texture_cache.ReclaimMemory(remaining - evicted, false);
+        }
+        if (evicted < remaining) {
+            evicted += buffer_cache.ReclaimMemory(remaining - evicted, false);
+        }
+        master_semaphore.Refresh();
+        const u64 completed_after = master_semaphore.KnownGpuTick();
+        texture_cache.ReclaimDeferredResources(completed_after);
+        buffer_cache.ReclaimDeferredResources(completed_after);
+        vk::TickDeletionQueue(completed_after);
+        return drained + evicted;
     });
 }
 

src/video_core/renderer_vulkan/vk_scheduler.cpp

@@ -346,6 +346,7 @@ bool Scheduler::UpdateRescaling(bool is_rescaling) {
 
 void Scheduler::WorkerThread(std::stop_token stop_token) {
     Common::SetCurrentThreadName("VulkanWorker");
+    Common::SetCurrentThreadPriority(Common::ThreadPriority::VeryHigh);
 
     const auto TryPopQueue{[this](auto& work) -> bool {
         if (work_queue.empty()) {

src/video_core/texture_cache/texture_cache.h

@@ -182,10 +182,9 @@ u64 TextureCache<P>::ReclaimMemory(u64 target_bytes, bool allow_download) {
         }
         const bool must_download = image.IsSafeDownload();
         if (must_download && True(image.flags & ImageFlagBits::BadOverlap)) {
-            LOG_WARNING(HW_GPU,
-                        "Recovering bad overlap on eviction: gpu_addr=0x{:x} fmt={} {}x{}x{}",
-                        image.gpu_addr, static_cast<u32>(image.info.format), image.info.size.width,
-                        image.info.size.height, image.info.size.depth);
+            LOG_DEBUG(HW_GPU, "Recovering bad overlap on eviction: gpu_addr=0x{:x} fmt={} {}x{}x{}",
+                      image.gpu_addr, static_cast<u32>(image.info.format), image.info.size.width,
+                      image.info.size.height, image.info.size.depth);
         }
         bool queued_download = false;
         if (must_download) {
@@ -226,6 +225,13 @@ u64 TextureCache<P>::ReclaimMemory(u64 target_bytes, bool allow_download) {
     return freed;
 }
 
+template <class P>
+void TextureCache<P>::ReclaimDeferredResources(u64 completed_sync_point) {
+    sentenced_images.Reclaim(completed_sync_point);
+    sentenced_framebuffers.Reclaim(completed_sync_point);
+    sentenced_image_view.Reclaim(completed_sync_point);
+}
+
 template <class P>
 void TextureCache<P>::EnsureHeadroom(bool allow_download) {
     if (reclaim_stalled) {
@@ -250,12 +256,10 @@ template <class P>
 void TextureCache<P>::TickFrame() {
     usage_refresh_countdown = 0;
     reclaim_stalled = false;
-    EnsureHeadroom(true);
     const u64 completed_sync_point = runtime.CompletedSyncPoint();
     TickEvictionDownloads(completed_sync_point);
-    sentenced_images.Reclaim(completed_sync_point);
-    sentenced_framebuffers.Reclaim(completed_sync_point);
-    sentenced_image_view.Reclaim(completed_sync_point);
+    ReclaimDeferredResources(completed_sync_point);
+    EnsureHeadroom(true);
     TickAsyncDecode();
     TickAsyncUnswizzle();
 
@@ -1241,8 +1245,6 @@ void TextureCache<P>::UploadImageContents(Image& image, StagingBuffer& staging)
         return;
     }
 
-    gpu_memory->FlushRegion(gpu_addr, image.guest_size_bytes,
-                            VideoCommon::CacheType::NoTextureCache);
     Tegra::Memory::GpuGuestMemory<u8, Tegra::Memory::GuestMemoryFlags::UnsafeRead> swizzle_data(
         *gpu_memory, gpu_addr, image.guest_size_bytes, &swizzle_data_buffer);
     if (True(image.flags & ImageFlagBits::Converted)) {
@@ -1608,7 +1610,7 @@ ImageId TextureCache<P>::InsertImage(const ImageInfo& info, GPUVAddr gpu_addr,
         }
     }
     ASSERT_MSG(cpu_addr, "Tried to insert an image to an invalid gpu_addr=0x{:x}", gpu_addr);
-    const ImageId image_id = JoinImages(info, gpu_addr, *cpu_addr);
+    const ImageId image_id = JoinImages(info, gpu_addr, *cpu_addr, options);
     const Image& image = slot_images[image_id];
     // Using "image.gpu_addr" instead of "gpu_addr" is important because it might be different
     const auto [it, is_new] = image_allocs_table.try_emplace(image.gpu_addr);
@@ -1620,7 +1622,8 @@ ImageId TextureCache<P>::InsertImage(const ImageInfo& info, GPUVAddr gpu_addr,
 }
 
 template <class P>
-ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, DAddr cpu_addr) {
+ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, DAddr cpu_addr,
+                                    RelaxedOptions options) {
     EnsureHeadroom(false);
     ImageInfo new_info = info;
     const size_t size_bytes = CalculateGuestSizeInBytes(new_info);
@@ -1632,9 +1635,11 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, DA
     join_right_aliased_ids.clear();
     join_ignore_textures.clear();
     join_bad_overlap_ids.clear();
+    join_stale_ids.clear();
     join_copies_to_do.clear();
     join_alias_indices.clear();
     const bool this_is_linear = info.type == ImageType::Linear;
+    const bool is_render_target = True(options & RelaxedOptions::RenderTarget);
     const auto region_check = [&](ImageId overlap_id, ImageBase& overlap) {
         if (True(overlap.flags & ImageFlagBits::Remapped)) {
             join_ignore_textures.insert(overlap_id);
@@ -1674,6 +1679,9 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, DA
             join_right_aliased_ids.push_back(overlap_id);
             overlap.flags |= ImageFlagBits::Alias;
             join_copies_to_do.emplace_back(JoinCopy{true, overlap_id});
+        } else if (is_render_target && IsStaleReallocation(new_info, overlap, gpu_addr) &&
+                   slot_images[overlap_id].allocation_tick != frame_tick) {
+            join_stale_ids.push_back(overlap_id);
         } else {
             join_bad_overlap_ids.push_back(overlap_id);
         }
@@ -1767,6 +1775,19 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, DA
         DeleteImage(overlap_id);
     }
 
+    for (const ImageId stale_id : join_stale_ids) {
+        Image& stale = slot_images[stale_id];
+        LOG_DEBUG(HW_GPU,
+                  "Retiring resized image: gpu_addr=0x{:x} fmt={} {}x{} -> {}x{}", stale.gpu_addr,
+                  static_cast<u32>(stale.info.format), stale.info.size.width,
+                  stale.info.size.height, new_image.info.size.width, new_image.info.size.height);
+        if (True(stale.flags & ImageFlagBits::Tracked)) {
+            UntrackImage(stale, stale_id);
+        }
+        UnregisterImage(stale_id);
+        DeleteImage(stale_id);
+    }
+
     // TODO: Only upload what we need
     RefreshContents(new_image, new_image_id);
 
@@ -1818,17 +1839,17 @@ ImageId TextureCache<P>::JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, DA
         const bool aliased_is_bad = True(aliased.flags & ImageFlagBits::BadOverlap);
         const bool new_is_bad = True(new_image.flags & ImageFlagBits::BadOverlap);
         if ((!aliased_was_bad && aliased_is_bad) || (!new_was_bad && new_is_bad)) {
-            LOG_WARNING(HW_GPU,
-                        "Bad overlap: existing gpu_addr={:#x} {}x{}x{} fmt={} type={} rt={} | "
-                        "incoming gpu_addr={:#x} {}x{}x{} fmt={} type={} rt={}",
-                        aliased.gpu_addr, aliased.info.size.width, aliased.info.size.height,
-                        aliased.info.size.depth, static_cast<u32>(aliased.info.format),
-                        static_cast<u32>(aliased.info.type),
-                        True(aliased.flags & ImageFlagBits::GpuModified),
-                        new_image.gpu_addr, new_image.info.size.width, new_image.info.size.height,
-                        new_image.info.size.depth, static_cast<u32>(new_image.info.format),
-                        static_cast<u32>(new_image.info.type),
-                        True(new_image.flags & ImageFlagBits::GpuModified));
+            LOG_DEBUG(HW_GPU,
+                      "Bad overlap: existing gpu_addr={:#x} {}x{}x{} fmt={} type={} rt={} | "
+                      "incoming gpu_addr={:#x} {}x{}x{} fmt={} type={} rt={}",
+                      aliased.gpu_addr, aliased.info.size.width, aliased.info.size.height,
+                      aliased.info.size.depth, static_cast<u32>(aliased.info.format),
+                      static_cast<u32>(aliased.info.type),
+                      True(aliased.flags & ImageFlagBits::GpuModified),
+                      new_image.gpu_addr, new_image.info.size.width, new_image.info.size.height,
+                      new_image.info.size.depth, static_cast<u32>(new_image.info.format),
+                      static_cast<u32>(new_image.info.type),
+                      True(new_image.flags & ImageFlagBits::GpuModified));
         }
     }
 
@@ -2120,7 +2141,7 @@ ImageViewId TextureCache<P>::FindRenderTargetView(const ImageInfo& info, GPUVAdd
     bool delete_state = has_deleted_images;
     do {
         has_deleted_images = false;
-        image_id = FindOrInsertImage(info, gpu_addr);
+        image_id = FindOrInsertImage(info, gpu_addr, RelaxedOptions::RenderTarget);
         delete_state |= has_deleted_images;
     } while (has_deleted_images);
     has_deleted_images = delete_state;

src/video_core/texture_cache/texture_cache_base.h

@@ -159,6 +159,8 @@ public:
 
     u64 ReclaimMemory(u64 target_bytes, bool allow_download);
 
+    void ReclaimDeferredResources(u64 completed_sync_point);
+
     /// Return a constant reference to the given image view id
     [[nodiscard]] const ImageView& GetImageView(ImageViewId id) const noexcept;
 
@@ -340,7 +342,8 @@ private:
 
     /// Create a new image and join perfectly matching existing images
     /// Remove joined images from the cache
-    [[nodiscard]] ImageId JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, DAddr cpu_addr);
+    [[nodiscard]] ImageId JoinImages(const ImageInfo& info, GPUVAddr gpu_addr, DAddr cpu_addr,
+                                     RelaxedOptions options);
 
     [[nodiscard]] ImageId FindDMAImage(const ImageInfo& info, GPUVAddr gpu_addr);
 
@@ -532,7 +535,7 @@ private:
     u64 last_sampler_gc_frame = (std::numeric_limits<u64>::max)();
 
     Common::ThreadWorker texture_decode_worker{1, "TextureDecoder", {},
-                                               Common::ThreadPlacement::Background};
+                                               Common::ThreadPlacement::Efficiency};
     std::vector<std::unique_ptr<AsyncDecodeContext>> async_decodes;
 
     std::deque<PendingUnswizzle> unswizzle_queue;
@@ -545,6 +548,7 @@ private:
     boost::container::small_vector<ImageId, 4> join_right_aliased_ids;
     ankerl::unordered_dense::set<ImageId> join_ignore_textures;
     boost::container::small_vector<ImageId, 4> join_bad_overlap_ids;
+    boost::container::small_vector<ImageId, 4> join_stale_ids;
     struct JoinCopy {
         bool is_alias;
         ImageId id;

src/video_core/texture_cache/types.h

@@ -57,6 +57,7 @@ enum class RelaxedOptions : u32 {
     Format = 1 << 1,
     Samples = 1 << 2,
     ForceBrokenViews = 1 << 3,
+    RenderTarget = 1 << 4,
 };
 DECLARE_ENUM_FLAG_OPERATORS(RelaxedOptions)
 

src/video_core/texture_cache/util.cpp

@@ -1194,6 +1194,35 @@ bool IsLayerStrideCompatible(const ImageInfo& lhs, const ImageInfo& rhs) {
     return false;
 }
 
+bool IsStaleReallocation(const ImageInfo& new_info, const ImageBase& overlap,
+                         GPUVAddr gpu_addr) noexcept {
+    if (overlap.gpu_addr != gpu_addr) {
+        return false;
+    }
+    const ImageInfo& info = overlap.info;
+    if (new_info.type != ImageType::e2D || info.type != ImageType::e2D) {
+        return false;
+    }
+    if (new_info.resources.levels != 1 || info.resources.levels != 1) {
+        return false;
+    }
+    if (new_info.resources.layers != info.resources.layers) {
+        return false;
+    }
+    if (new_info.block != info.block || new_info.num_samples != info.num_samples) {
+        return false;
+    }
+    if (new_info.tile_width_spacing != info.tile_width_spacing) {
+        return false;
+    }
+    if (BytesPerBlock(new_info.format) != BytesPerBlock(info.format) ||
+        DefaultBlockWidth(new_info.format) != DefaultBlockWidth(info.format) ||
+        DefaultBlockHeight(new_info.format) != DefaultBlockHeight(info.format)) {
+        return false;
+    }
+    return new_info.size.width != info.size.width || new_info.size.height != info.size.height;
+}
+
 std::optional<SubresourceBase> FindSubresource(const ImageInfo& candidate, const ImageBase& image,
                                                GPUVAddr candidate_addr, RelaxedOptions options,
                                                bool broken_views, bool native_bgr) {

src/video_core/texture_cache/util.h

@@ -104,6 +104,9 @@ void SwizzleImage(Tegra::MemoryManager& gpu_memory, GPUVAddr gpu_addr, const Ima
 
 [[nodiscard]] bool IsLayerStrideCompatible(const ImageInfo& lhs, const ImageInfo& rhs);
 
+[[nodiscard]] bool IsStaleReallocation(const ImageInfo& new_info, const ImageBase& overlap,
+                                       GPUVAddr gpu_addr) noexcept;
+
 [[nodiscard]] std::optional<SubresourceBase> FindSubresource(const ImageInfo& candidate,
                                                              const ImageBase& image,
                                                              GPUVAddr candidate_addr,

src/video_core/textures/workers.cpp

@@ -11,7 +11,7 @@ namespace Tegra::Texture {
 Common::ThreadWorker& GetThreadWorkers() {
     static Common::ThreadWorker workers{(std::max)(std::thread::hardware_concurrency(), 2U) / 2,
                                         "ImageTranscode", {},
-                                        Common::ThreadPlacement::Background};
+                                        Common::ThreadPlacement::Efficiency};
 
     return workers;
 }

src/video_core/vulkan_common/vulkan_device.cpp

@@ -1256,6 +1256,11 @@ bool Device::GetSuitability(bool requires_swapchain) {
             VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT;
         SetNext(next, properties.external_memory_host);
     }
+    if (extensions.maintenance3 || instance_version >= VK_API_VERSION_1_1) {
+        properties.maintenance3.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
+        SetNext(next, properties.maintenance3);
+    }
     if (extensions.maintenance4 || features.maintenance4.maintenance4) {
         properties.maintenance4.sType =
             VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;

src/video_core/vulkan_common/vulkan_device.h

@@ -416,7 +416,8 @@ FN_MAX_LIMIT_LIST
 
     /// Returns true if descriptor aliasing is natively supported.
     bool IsDescriptorAliasingSupported() const {
-        return GetDriverID() != VK_DRIVER_ID_QUALCOMM_PROPRIETARY;
+        return features.descriptor_indexing.descriptorBindingPartiallyBound &&
+               features.descriptor_indexing.descriptorBindingVariableDescriptorCount;
     }
 
     bool IsSampledImageArrayNonUniformIndexingSupported() const {
@@ -947,6 +948,10 @@ FN_MAX_LIMIT_LIST
         return properties.maintenance4.maxBufferSize;
     }
 
+    u64 GetMaxMemoryAllocationSize() const {
+        return properties.maintenance3.maxMemoryAllocationSize;
+    }
+
     bool HasTimelineSemaphore() const;
 
     /// Returns true if the device supports VK_KHR_synchronization2.
@@ -1295,6 +1300,7 @@ private:
         VkPhysicalDeviceDescriptorBufferPropertiesEXT descriptor_buffer{};
         VkPhysicalDeviceSubgroupSizeControlProperties subgroup_size_control{};
         VkPhysicalDeviceTransformFeedbackPropertiesEXT transform_feedback{};
+        VkPhysicalDeviceMaintenance3Properties maintenance3{};
         VkPhysicalDeviceMaintenance4Properties maintenance4{};
         VkPhysicalDeviceMaintenance5PropertiesKHR maintenance5{};
         VkPhysicalDeviceDepthStencilResolveProperties depth_stencil_resolve{};

src/video_core/vulkan_common/vulkan_memory_allocator.cpp

@@ -95,15 +95,22 @@ namespace Vulkan {
 
     HostMemoryImport::HostMemoryImport(const Device &device_, void *base, size_t size,
                                        std::span<AHardwareBuffer *const> hardware_buffers,
-                                       size_t hardware_buffer_window)
+                                       size_t hardware_buffer_window, size_t hardware_buffer_base)
             : device{device_} {
+        if (ImportHardwareBuffers(hardware_buffers, hardware_buffer_window, hardware_buffer_base,
+                                  size)) {
+            return;
+        }
+        if (!hardware_buffers.empty()) {
+            LOG_INFO(Render_Vulkan,
+                     "Unified memory disabled, guest memory is backed by hardware buffers that "
+                     "could not be imported");
+            return;
+        }
         if (ImportHostPointer(base, size)) {
             return;
         }
-        ImportHardwareBuffers(hardware_buffers, hardware_buffer_window, size);
-        if (windows.empty()) {
-            LOG_INFO(Render_Vulkan, "Unified memory disabled, no host memory import path");
-        }
+        LOG_INFO(Render_Vulkan, "Unified memory disabled, no host memory import path");
     }
 
     bool HostMemoryImport::ImportHostPointer(void *base, size_t size) {
@@ -124,8 +131,13 @@ namespace Vulkan {
         VkDeviceSize candidate_window = 1_GiB;
         const u64 max_buffer_size = device.GetMaxBufferSize();
         if (max_buffer_size != 0 && max_buffer_size < candidate_window) {
-            candidate_window = Common::AlignDown(max_buffer_size, alignment);
+            candidate_window = max_buffer_size;
         }
+        const u64 max_allocation_size = device.GetMaxMemoryAllocationSize();
+        if (max_allocation_size != 0 && max_allocation_size < candidate_window) {
+            candidate_window = max_allocation_size;
+        }
+        candidate_window = Common::AlignDown(candidate_window, alignment);
         if (candidate_window == 0) {
             return false;
         }
@@ -226,19 +238,31 @@ namespace Vulkan {
         return true;
     }
 
-    void HostMemoryImport::ImportHardwareBuffers(
+    bool HostMemoryImport::ImportHardwareBuffers(
             [[maybe_unused]] std::span<AHardwareBuffer *const> hardware_buffers,
-            [[maybe_unused]] size_t hardware_buffer_window, [[maybe_unused]] size_t size) {
+            [[maybe_unused]] size_t hardware_buffer_window,
+            [[maybe_unused]] size_t hardware_buffer_base, [[maybe_unused]] size_t size) {
 #ifdef __ANDROID__
         if (hardware_buffers.empty() || hardware_buffer_window == 0 ||
             !device.IsExtExternalMemoryAhbSupported()) {
-            return;
+            return false;
+        }
+        const u64 max_allocation_size = device.GetMaxMemoryAllocationSize();
+        if (max_allocation_size != 0 && hardware_buffer_window > max_allocation_size) {
+            LOG_WARNING(Render_Vulkan,
+                        "Hardware buffer windows of {} MiB exceed the {} MiB allocation limit",
+                        hardware_buffer_window >> 20, max_allocation_size >> 20);
+            return false;
+        }
+        if (hardware_buffer_base >= size) {
+            return false;
         }
         const auto &logical = device.GetLogical();
         const auto memory_props = device.GetPhysical().GetMemoryProperties().memoryProperties;
         window_size = hardware_buffer_window;
+        base_offset = hardware_buffer_base;
         for (size_t i = 0; i < hardware_buffers.size(); ++i) {
-            const size_t offset = i * hardware_buffer_window;
+            const size_t offset = hardware_buffer_base + i * hardware_buffer_window;
             if (offset >= size) {
                 break;
             }
@@ -320,11 +344,19 @@ namespace Vulkan {
             });
             imported_size += static_cast<size_t>(window_len);
         }
-        if (!windows.empty()) {
-            LOG_INFO(Render_Vulkan,
-                     "Imported {} MiB of guest memory via hardware buffers in {} windows",
-                     imported_size >> 20, windows.size());
+        if (windows.empty()) {
+            LOG_INFO(Render_Vulkan, "Hardware buffer import failed");
+            window_size = 0;
+            base_offset = 0;
+            return false;
         }
+        foreign_ownership = true;
+        LOG_INFO(Render_Vulkan,
+                 "Imported {} MiB of guest memory at {:#x} via hardware buffers in {} windows",
+                 imported_size >> 20, base_offset, windows.size());
+        return true;
+#else
+        return false;
 #endif
     }
 

src/video_core/vulkan_common/vulkan_memory_allocator.h

@@ -46,7 +46,7 @@ namespace Vulkan {
     public:
         explicit HostMemoryImport(const Device &device_, void *base, size_t size,
                                   std::span<AHardwareBuffer *const> hardware_buffers,
-                                  size_t hardware_buffer_window);
+                                  size_t hardware_buffer_window, size_t hardware_buffer_base);
 
         ~HostMemoryImport();
 
@@ -62,6 +62,14 @@ namespace Vulkan {
             return imported_size;
         }
 
+        [[nodiscard]] size_t GetBaseOffset() const noexcept {
+            return base_offset;
+        }
+
+        [[nodiscard]] bool NeedsForeignOwnershipTransfer() const noexcept {
+            return foreign_ownership;
+        }
+
         [[nodiscard]] VkDeviceSize GetWindowSize() const noexcept {
             return window_size;
         }
@@ -82,13 +90,16 @@ namespace Vulkan {
 
         bool ImportHostPointer(void *base, size_t size);
 
-        void ImportHardwareBuffers(std::span<AHardwareBuffer *const> hardware_buffers,
-                                   size_t hardware_buffer_window, size_t size);
+        bool ImportHardwareBuffers(std::span<AHardwareBuffer *const> hardware_buffers,
+                                   size_t hardware_buffer_window, size_t hardware_buffer_base,
+                                   size_t size);
 
         const Device &device;
         std::vector<Window> windows;
         VkDeviceSize window_size{};
         size_t imported_size{};
+        size_t base_offset{};
+        bool foreign_ownership{};
     };
 
 /// Memory allocator container.