Step back + keeping fixes from unified download + shared mem refactor

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/BooleanSetting.kt

@@ -27,6 +27,7 @@ enum class BooleanSetting(override val key: String) : AbstractBooleanSetting {
     RENDERER_ASYNCHRONOUS_GPU_EMULATION("use_asynchronous_gpu_emulation"),
     RENDERER_ASYNC_PRESENTATION("async_presentation"),
     RENDERER_ASYNCHRONOUS_SHADERS("use_asynchronous_shaders"),
+    RENDERER_UNIFIED_MEMORY("use_unified_memory"),
     RENDERER_REACTIVE_FLUSHING("use_reactive_flushing"),
     ENABLE_BUFFER_HISTORY("enable_buffer_history"),
     USE_OPTIMIZED_VERTEX_BUFFERS("use_optimized_vertex_buffers"),

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/model/view/SettingsItem.kt

@@ -685,6 +685,13 @@ abstract class SettingsItem(
                     descriptionId = R.string.renderer_asynchronous_shaders_description
                 )
             )
+            put(
+                SwitchSetting(
+                    BooleanSetting.RENDERER_UNIFIED_MEMORY,
+                    titleId = R.string.renderer_unified_memory,
+                    descriptionId = R.string.renderer_unified_memory_description
+                )
+            )
             put(
                 SingleChoiceSetting(
                     IntSetting.FAST_GPU_TIME,

src/android/app/src/main/java/org/yuzu/yuzu_emu/features/settings/ui/SettingsFragmentPresenter.kt

@@ -304,6 +304,7 @@ class SettingsFragmentPresenter(
             add(BooleanSetting.EMULATE_BGR565.key)
             add(BooleanSetting.RESCALE_HACK.key)
             add(BooleanSetting.RENDERER_ASYNCHRONOUS_SHADERS.key)
+            add(BooleanSetting.RENDERER_UNIFIED_MEMORY.key)
             add(IntSetting.ANDROID_PIPELINE_WORKERS.key)
             add(BooleanSetting.RENDERER_ASYNCHRONOUS_GPU_EMULATION.key)
             add(BooleanSetting.RENDERER_ASYNC_PRESENTATION.key)

src/android/app/src/main/res/values/strings.xml

@@ -524,6 +524,8 @@
     <string name="rescale_hack_description">Enables a legacy handling for the rescale configuration pass for games by using a quick rescale path</string>
     <string name="renderer_asynchronous_shaders">Use asynchronous shaders</string>
     <string name="renderer_asynchronous_shaders_description">Compiles shaders asynchronously. This may reduce stutters but may also introduce glitches.</string>
+    <string name="renderer_unified_memory">Unified memory access</string>
+    <string name="renderer_unified_memory_description">Allows GPU write buffer readbacks directly into guest memory, skipping the CPU staging copy.</string>
     <string name="gpu_unswizzle_settings">GPU Unswizzle Settings</string>
     <string name="gpu_unswizzle_settings_description">Configure GPU-based texture unswizzling parameters or disable it entirely. Adjust these settings to balance performance and texture loading quality.</string>
     <string name="gpu_unswizzle_enable">Enable GPU Unswizzle</string>

src/common/heap_tracker.cpp

@@ -31,7 +31,9 @@ s64 GetMaxPermissibleResidentMapCount() {
 } // namespace
 
 HeapTracker::HeapTracker(Common::HostMemory& buffer)
-    : m_buffer(buffer), m_max_resident_map_count(GetMaxPermissibleResidentMapCount()) {}
+    : m_buffer(buffer),
+      m_has_hardware_buffer_backing(!buffer.BackingHardwareBuffers().empty()),
+      m_max_resident_map_count(GetMaxPermissibleResidentMapCount()) {}
 HeapTracker::~HeapTracker() = default;
 
 void HeapTracker::Map(size_t virtual_offset, size_t host_offset, size_t length,
@@ -85,7 +87,8 @@ void HeapTracker::Unmap(size_t virtual_offset, size_t size, bool is_separate_hea
 
             // If resident, erase from resident map.
             if (item->is_resident) {
-                ASSERT(--m_resident_map_count >= 0);
+                m_resident_map_count -= this->HostMapCount(item->paddr, item->size);
+                ASSERT(m_resident_map_count >= 0);
                 m_resident_mappings.erase(m_resident_mappings.iterator_to(*item));
             }
 
@@ -191,7 +194,7 @@ bool HeapTracker::DeferredMapSeparateHeap(size_t virtual_offset) {
 
         // This map is now resident.
         it->is_resident = true;
-        m_resident_map_count++;
+        m_resident_map_count += this->HostMapCount(it->paddr, it->size);
         m_resident_mappings.insert(*it);
     }
 
@@ -213,17 +216,17 @@ void HeapTracker::RebuildSeparateHeapAddressSpace() {
     // Despite being worse in theory, this has proven to be better in practice than more
     // regularly dumping a smaller amount, because it significantly reduces average case
     // lock contention.
-    std::size_t const desired_count = (std::min)(m_resident_map_count, m_max_resident_map_count) / 2;
-    std::size_t const evict_count = m_resident_map_count - desired_count;
+    s64 const desired_count = (std::min)(m_resident_map_count, m_max_resident_map_count) / 2;
     auto it = m_resident_mappings.begin();
 
-    for (size_t i = 0; i < evict_count && it != m_resident_mappings.end(); i++) {
+    while (m_resident_map_count > desired_count && it != m_resident_mappings.end()) {
         // Unmark and unmap.
         it->is_resident = false;
         m_buffer.Unmap(it->vaddr, it->size, false);
 
         // Advance.
-        ASSERT(--m_resident_map_count >= 0);
+        m_resident_map_count -= this->HostMapCount(it->paddr, it->size);
+        ASSERT(m_resident_map_count >= 0);
         it = m_resident_mappings.erase(it);
     }
 }
@@ -245,6 +248,7 @@ void HeapTracker::SplitHeapMapLocked(VAddr offset) {
     // Cache the original values.
     auto* const left = std::addressof(*it);
     const size_t orig_size = left->size;
+    const s64 orig_host_map_count = this->HostMapCount(left->paddr, orig_size);
 
     // Adjust the left map.
     const size_t left_size = offset - left->vaddr;
@@ -266,11 +270,20 @@ void HeapTracker::SplitHeapMapLocked(VAddr offset) {
 
     // If resident, also insert into resident map.
     if (right->is_resident) {
-        m_resident_map_count++;
+        m_resident_map_count += this->HostMapCount(left->paddr, left->size) +
+                                this->HostMapCount(right->paddr, right->size) -
+                                orig_host_map_count;
         m_resident_mappings.insert(*right);
     }
 }
 
+s64 HeapTracker::HostMapCount(PAddr paddr, size_t size) const {
+    if (!m_has_hardware_buffer_backing) {
+        return size != 0 ? 1 : 0;
+    }
+    return static_cast<s64>(m_buffer.BackingMapCount(paddr, size));
+}
+
 HeapTracker::AddrTree::iterator HeapTracker::GetNearestHeapMapLocked(VAddr offset) {
     const SeparateHeapMap key{
         .vaddr = offset,

src/common/heap_tracker.h

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -82,10 +85,13 @@ private:
 
     AddrTree::iterator GetNearestHeapMapLocked(VAddr offset);
 
+    s64 HostMapCount(PAddr paddr, size_t size) const;
+
     void RebuildSeparateHeapAddressSpace();
 
 private:
     Common::HostMemory& m_buffer;
+    const bool m_has_hardware_buffer_backing;
     const s64 m_max_resident_map_count;
 
     std::shared_mutex m_rebuild_lock{};

src/common/host_memory.cpp

@@ -51,14 +51,45 @@
 
 #endif // ^^^ POSIX ^^^
 
+#include <atomic>
 #include <mutex>
 #include <random>
+#include <vector>
 
 #include "common/alignment.h"
 #include "common/assert.h"
 #include "common/free_region_manager.h"
 #include "common/host_memory.h"
 #include "common/logging.h"
+#include "common/memory_detect.h"
+#include "common/settings.h"
+
+#ifdef __ANDROID__
+#include <dlfcn.h>
+#include <android/hardware_buffer.h>
+
+namespace {
+
+struct NativeHandle {
+    int version;
+    int numFds;
+    int numInts;
+    int data[1];
+};
+
+using PFN_AHardwareBuffer_getNativeHandle = const NativeHandle* (*)(const AHardwareBuffer*);
+
+PFN_AHardwareBuffer_getNativeHandle ResolveGetNativeHandle() {
+    void* const lib = dlopen("libnativewindow.so", RTLD_NOW);
+    if (lib == nullptr) {
+        return nullptr;
+    }
+    return reinterpret_cast<PFN_AHardwareBuffer_getNativeHandle>(
+        dlsym(lib, "AHardwareBuffer_getNativeHandle"));
+}
+
+} // namespace
+#endif
 
 #if defined(__ANDROID__) && __ANDROID_API__ < 30
 #include <sys/syscall.h>
@@ -75,6 +106,12 @@ namespace Common {
 [[maybe_unused]] constexpr size_t PageAlignment = 0x1000;
 [[maybe_unused]] constexpr size_t HugePageSize = 0x200000;
 
+static std::atomic<u64> committed_backing_size{};
+
+u64 GetCommittedBackingSize() noexcept {
+    return committed_backing_size.load(std::memory_order_relaxed);
+}
+
 #ifdef _WIN32
 
 // Manually imported for MinGW compatibility
@@ -123,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()}
@@ -229,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
 
@@ -501,9 +542,10 @@ 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() {
@@ -543,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) {
@@ -554,7 +601,10 @@ public:
             return false;
         }
 
-        // Virtual memory initialization
+        return InitVirtual();
+    }
+
+    bool InitVirtual() {
         virtual_base = virtual_map_base = static_cast<u8*>(ChooseVirtualBase(virtual_size));
         if (virtual_base == MAP_FAILED) {
             LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno));
@@ -567,6 +617,242 @@ public:
         return true;
     }
 
+#ifdef __ANDROID__
+    static AHardwareBuffer_Desc MakeBlobDesc(size_t len) {
+        return AHardwareBuffer_Desc{
+            .width = static_cast<u32>(len),
+            .height = 1,
+            .layers = 1,
+            .format = AHARDWAREBUFFER_FORMAT_BLOB,
+            .usage = AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN |
+                     AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN |
+                     AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER,
+            .stride = 0,
+            .rfu0 = 0,
+            .rfu1 = 0,
+        };
+    }
+
+    static bool ProbeAhbBacking(PFN_AHardwareBuffer_getNativeHandle get_native_handle) {
+        const AHardwareBuffer_Desc desc = MakeBlobDesc(PageAlignment * 2);
+        AHardwareBuffer* buffer{};
+        if (AHardwareBuffer_allocate(&desc, &buffer) != 0 || buffer == nullptr) {
+            return false;
+        }
+        const NativeHandle* const handle = get_native_handle(buffer);
+        if (handle == nullptr || handle->numFds < 1) {
+            AHardwareBuffer_release(buffer);
+            return false;
+        }
+        const int probe_fd = handle->data[0];
+        bool ok = true;
+        const auto try_map = [&](int prot, off_t offset, const char* what) {
+            if (!ok) {
+                return;
+            }
+            void* const ptr = mmap(nullptr, PageAlignment, prot, MAP_SHARED, probe_fd, offset);
+            if (ptr == MAP_FAILED) {
+                ok = false;
+                return;
+            }
+            munmap(ptr, PageAlignment);
+        };
+        try_map(PROT_READ | PROT_WRITE, 0, "shared mappings");
+        try_map(PROT_READ | PROT_WRITE, static_cast<off_t>(PageAlignment), "mappings at an offset");
+#ifdef ARCHITECTURE_arm64
+        try_map(PROT_READ | PROT_EXEC, 0, "executable mappings");
+#endif
+        AHardwareBuffer_release(buffer);
+        return ok;
+    }
+
+    size_t ComputeAhbBudget(size_t window_size) const {
+        const u64 total_physical = Common::GetMemInfo().TotalPhysicalMemory;
+        constexpr u64 BaselineFootprint = 6ULL << 30;
+        if (total_physical <= BaselineFootprint) {
+            return 0;
+        }
+        const u64 max_map_count = Common::GetMaxMapCount();
+        constexpr u64 ReservedMaps = 24576;
+        if (max_map_count == 0 || max_map_count <= ReservedMaps) {
+            return 0;
+        }
+        u64 budget = (total_physical - BaselineFootprint) / 2;
+        constexpr u64 MapSlotsPerWindow = 4096;
+        const u64 affordable_windows = (max_map_count - ReservedMaps) / MapSlotsPerWindow;
+        budget = (std::min)(budget, affordable_windows * window_size);
+        const u64 available = Common::GetAvailablePhysicalMemory();
+        if (available != 0) {
+            budget = (std::min)(budget, available / 2);
+        }
+        budget = (std::min)(budget, static_cast<u64>(backing_size));
+        budget = Common::AlignDown(budget, window_size);
+        constexpr u64 MinimumBudget = 256ULL << 20;
+        if (budget < MinimumBudget) {
+            return 0;
+        }
+        return static_cast<size_t>(budget);
+    }
+
+    bool InitAhbBacking() {
+        if (!Settings::values.use_unified_memory.GetValue()) {
+            return false;
+        }
+        static const PFN_AHardwareBuffer_getNativeHandle get_native_handle =
+            ResolveGetNativeHandle();
+        if (get_native_handle == nullptr) {
+            return false;
+        }
+        constexpr size_t window_size = 256ULL << 20;
+        const size_t budget = ComputeAhbBudget(window_size);
+        if (budget == 0) {
+            return false;
+        }
+        if (!ProbeAhbBacking(get_native_handle)) {
+            return false;
+        }
+        const size_t aligned_backing = Common::AlignDown(backing_size, window_size);
+        const size_t max_windows = (std::min)(budget, aligned_backing) / 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 < max_windows; ++i) {
+            const AHardwareBuffer_Desc desc = MakeBlobDesc(window_size);
+            AHardwareBuffer* buffer{};
+            if (AHardwareBuffer_allocate(&desc, &buffer) != 0 || buffer == nullptr) {
+                break;
+            }
+            const NativeHandle* const handle = get_native_handle(buffer);
+            if (handle == nullptr || handle->numFds < 1) {
+                AHardwareBuffer_release(buffer);
+                break;
+            }
+            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)) {
+                AHardwareBuffer_release(buffer);
+                break;
+            }
+            buffers.push_back(buffer);
+            buffer_fds.push_back(buffer_fd);
+        }
+        const size_t num_windows = buffers.size();
+        if (num_windows == 0) {
+            return false;
+        }
+        const size_t region_size = num_windows * window_size;
+        const size_t region_base = Common::AlignDown(
+            (std::min)(preferred_offset, aligned_backing - region_size), window_size);
+        u8* const base = static_cast<u8*>(mmap(nullptr, backing_size, PROT_NONE,
+                                               MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0));
+        if (base == MAP_FAILED) {
+            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;
+            }
+            if (mmap(base + offset, len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_FIXED, map_fd,
+                     map_offset) == MAP_FAILED) {
+                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);
+        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;
+        }
+    }
+
+    size_t BackingMapCount(size_t host_offset, size_t length) const noexcept {
+        if (length == 0) {
+            return 0;
+        }
+        if (ahb_bytes == 0) {
+            return 1;
+        }
+        size_t count = 0;
+        while (length > 0) {
+            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 local = (host_offset - ahb_base) % ahb_window_size;
+                chunk = (std::min)(chunk, ahb_window_size - local);
+            }
+            host_offset += chunk;
+            length -= chunk;
+            ++count;
+        }
+        return count;
+    }
+
+    std::span<AHardwareBuffer* const> AhbWindows() const noexcept {
+        return ahb_windows;
+    }
+
+    size_t AhbWindowSize() const noexcept {
+        return ahb_bytes != 0 ? ahb_window_size : 0;
+    }
+
+    size_t AhbBase() const noexcept {
+        return ahb_base;
+    }
+#endif
+
     ~Impl() {
         Release();
     }
@@ -587,6 +873,12 @@ public:
 #ifdef ARCHITECTURE_arm64
         if (True(perms & MemoryPermission::Execute))
             prot_flags |= PROT_EXEC;
+#endif
+#ifdef __ANDROID__
+        if (ahb_bytes != 0) {
+            MapBackingRange(virtual_offset, host_offset, length, prot_flags);
+            return;
+        }
 #endif
         int flags = (fd >= 0 ? MAP_SHARED : MAP_PRIVATE) | MAP_FIXED;
         void* ret = mmap(virtual_base + virtual_offset, length, prot_flags, flags, fd, host_offset);
@@ -632,8 +924,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)};
@@ -656,6 +958,18 @@ private:
             int ret = close(fd);
             ASSERT_MSG(ret == 0, "close failed: {}", strerror(errno));
         }
+
+#ifdef __ANDROID__
+        for (AHardwareBuffer* buffer : ahb_windows) {
+            AHardwareBuffer_release(buffer);
+        }
+        ahb_windows.clear();
+        ahb_fds.clear();
+        if (ahb_bytes != 0) {
+            committed_backing_size.store(0, std::memory_order_relaxed);
+            ahb_bytes = 0;
+        }
+#endif
     }
 
     void AdjustMap(size_t* virtual_offset, size_t* length) {
@@ -681,11 +995,19 @@ private:
 
     int fd{-1}; // memfd file descriptor, -1 is the error value of memfd_create
     FreeRegionManager free_manager{};
+
+#ifdef __ANDROID__
+    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_)
 {
@@ -697,7 +1019,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;
@@ -767,6 +1089,46 @@ void HostMemory::ClearBackingRegion(size_t physical_offset, size_t length, u32 f
     std::memset(backing_base + physical_offset, fill_value, length);
 }
 
+std::span<AHardwareBuffer* const> HostMemory::BackingHardwareBuffers() const noexcept {
+#ifdef __ANDROID__
+    return impl ? impl->AhbWindows() : std::span<AHardwareBuffer* const>{};
+#else
+    return {};
+#endif
+}
+
+size_t HostMemory::BackingMapCount(size_t host_offset, size_t length) const noexcept {
+#ifdef __ANDROID__
+    return impl ? impl->BackingMapCount(host_offset, length) : (length != 0 ? 1 : 0);
+#else
+    return length != 0 ? 1 : 0;
+#endif
+}
+
+size_t HostMemory::BackingHardwareBufferWindowSize() const noexcept {
+#ifdef __ANDROID__
+    return impl ? impl->AhbWindowSize() : 0;
+#else
+    return 0;
+#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

@@ -8,12 +8,17 @@
 
 #include <memory>
 #include <optional>
+#include <span>
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/virtual_buffer.h"
 
+struct AHardwareBuffer;
+
 namespace Common {
 
+[[nodiscard]] u64 GetCommittedBackingSize() noexcept;
+
 enum class MemoryPermission : u32 {
     Read = 1 << 0,
     Write = 1 << 1,
@@ -28,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();
 
     /**
@@ -62,6 +67,20 @@ public:
         return backing_base;
     }
 
+    [[nodiscard]] size_t BackingSize() const noexcept {
+        return backing_size;
+    }
+
+    [[nodiscard]] size_t BackingMapCount(size_t host_offset, size_t length) const noexcept;
+
+    [[nodiscard]] std::span<AHardwareBuffer* const> BackingHardwareBuffers() const noexcept;
+
+    [[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

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -17,6 +20,10 @@
 #endif
 #endif
 
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
 #include "common/memory_detect.h"
 
 namespace Common {
@@ -69,4 +76,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

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -18,4 +21,8 @@ struct MemoryInfo {
  */
 [[nodiscard]] const MemoryInfo& GetMemInfo();
 
+[[nodiscard]] u64 GetAvailablePhysicalMemory();
+
+[[nodiscard]] u64 GetMaxMapCount();
+
 } // namespace Common

src/common/settings.h

@@ -587,6 +587,9 @@ struct Values {
     SwitchableSetting<bool> use_asynchronous_shaders{linkage, false, "use_asynchronous_shaders",
                                                      Category::RendererHacks};
 
+    SwitchableSetting<bool> use_unified_memory{linkage, false, "use_unified_memory",
+                                               Category::RendererHacks};
+
     SwitchableSetting<GpuUnswizzleSize> gpu_unswizzle_texture_size{linkage,
                                                   GpuUnswizzleSize::Large,
                                                   "gpu_unswizzle_texture_size",

src/core/core.cpp

@@ -119,6 +119,7 @@ struct System::Impl {
 
         is_multicore = Settings::values.use_multi_core.GetValue();
         extended_memory_layout = Settings::values.memory_layout_mode.GetValue() != Settings::MemoryLayout::Memory_4Gb;
+        unified_memory = Settings::values.use_unified_memory.GetValue();
 
         core_timing.SetMulticore(is_multicore);
         core_timing.Initialize([&system]() { system.RegisterHostThread(); });
@@ -146,7 +147,8 @@ struct System::Impl {
             !device_memory.has_value() ||
             is_multicore != Settings::values.use_multi_core.GetValue() ||
             extended_memory_layout != (Settings::values.memory_layout_mode.GetValue() !=
-                                       Settings::MemoryLayout::Memory_4Gb);
+                                       Settings::MemoryLayout::Memory_4Gb) ||
+            unified_memory != Settings::values.use_unified_memory.GetValue();
 
         if (!must_reinitialize) {
             return;
@@ -157,6 +159,7 @@ struct System::Impl {
         is_multicore = Settings::values.use_multi_core.GetValue();
         extended_memory_layout =
             Settings::values.memory_layout_mode.GetValue() != Settings::MemoryLayout::Memory_4Gb;
+        unified_memory = Settings::values.use_unified_memory.GetValue();
 
         Initialize(system);
     }
@@ -503,6 +506,7 @@ struct System::Impl {
     std::atomic_bool is_powered_on{};
     bool is_multicore : 1 = false;
     bool extended_memory_layout : 1 = false;
+    bool unified_memory : 1 = false;
     bool exit_locked : 1 = false;
     bool exit_requested : 1 = false;
     bool nvdec_active : 1 = false;

src/core/device_memory.cpp

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 // SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -12,9 +15,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

@@ -20,6 +20,8 @@
 #include "common/scratch_buffer.h"
 #include "common/virtual_buffer.h"
 
+struct AHardwareBuffer;
+
 namespace Core {
 
 constexpr size_t DEVICE_PAGEBITS = 12ULL;
@@ -95,6 +97,34 @@ public:
         ApplyOpOnPAddr(address, buffer, operation);
     }
 
+    u8* GetPhysicalBase() noexcept {
+        return reinterpret_cast<u8*>(physical_base);
+    }
+
+    const u8* GetPhysicalBase() const noexcept {
+        return reinterpret_cast<const u8*>(physical_base);
+    }
+
+    size_t GetPhysicalSize() const noexcept {
+        return physical_size;
+    }
+
+    std::span<AHardwareBuffer* const> GetBackingHardwareBuffers() const noexcept {
+        return ahb_windows;
+    }
+
+    size_t GetBackingHardwareBufferWindowSize() const noexcept {
+        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;
@@ -171,6 +201,11 @@ private:
     std::unique_ptr<DeviceMemoryManagerAllocator<Traits>> impl;
 
     const uintptr_t physical_base;
+    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

@@ -171,6 +171,11 @@ struct DeviceMemoryManagerAllocator {
 template <typename Traits>
 DeviceMemoryManager<Traits>::DeviceMemoryManager(const DeviceMemory& device_memory_)
     : physical_base{uintptr_t(device_memory_.buffer.BackingBasePointer())}
+    , 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/qt_common/config/shared_translation.cpp

@@ -227,6 +227,8 @@ std::unique_ptr<TranslationMap> InitializeTranslations(QObject* parent) {
            tr("Preserves GPU-modified data by reading it back before uploading.\nSome games require this to render certain effects properly."));
     INSERT(Settings, use_asynchronous_shaders, tr("Enable asynchronous shader compilation"),
            tr("May reduce shader stutter."));
+    INSERT(Settings, use_unified_memory, tr("Enable unified memory access"),
+           tr("Lets the GPU write buffer readbacks directly into guest memory."));
     INSERT(Settings, gpu_clock, tr("GPU Clocks"),
            tr("Makes the game believe GPU work finishes faster than it does, so it stops lowering "
               "resolution and render distance to fit the Switch's clocks."));

src/shader_recompiler/backend/spirv/emit_spirv_atomic.cpp

@@ -13,6 +13,7 @@
 namespace Shader::Backend::SPIRV {
 namespace {
 Id SharedPointer(EmitContext& ctx, Id offset, u32 index_offset = 0) {
+    offset = ctx.BoundSharedOffset(offset, 4 + index_offset * 4);
     const Id shift_id{ctx.Const(2U)};
     Id index{ctx.OpShiftRightArithmetic(ctx.U32[1], offset, shift_id)};
     if (index_offset > 0) {
@@ -160,7 +161,8 @@ Id EmitSharedAtomicExchange32(EmitContext& ctx, Id offset, Id value) {
 Id EmitSharedAtomicExchange64(EmitContext& ctx, Id offset, Id value) {
     if (ctx.profile.support_shared_int64_atomics && ctx.uses_explicit_workgroup_layout) {
         const Id shift_id{ctx.Const(3U)};
-        const Id index{ctx.OpShiftRightArithmetic(ctx.U32[1], offset, shift_id)};
+        const Id index{
+            ctx.OpShiftRightArithmetic(ctx.U32[1], ctx.BoundSharedOffset(offset, 8), shift_id)};
         const Id pointer{
             ctx.OpAccessChain(ctx.shared_u64, ctx.shared_memory_u64, ctx.u32_zero_value, index)};
         const auto [scope, semantics]{AtomicArgs(ctx)};

src/shader_recompiler/backend/spirv/emit_spirv_shared_memory.cpp

@@ -31,6 +31,7 @@ std::pair<Id, Id> ExtractArgs(EmitContext& ctx, Id offset, u32 mask, u32 count)
 } // Anonymous namespace
 
 Id EmitLoadSharedU8(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 1);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{
             ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};
@@ -42,6 +43,7 @@ Id EmitLoadSharedU8(EmitContext& ctx, Id offset) {
 }
 
 Id EmitLoadSharedS8(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 1);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{
             ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};
@@ -53,6 +55,7 @@ Id EmitLoadSharedS8(EmitContext& ctx, Id offset) {
 }
 
 Id EmitLoadSharedU16(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 2);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};
         return ctx.OpUConvert(ctx.U32[1], ctx.OpLoad(ctx.U16, pointer));
@@ -63,6 +66,7 @@ Id EmitLoadSharedU16(EmitContext& ctx, Id offset) {
 }
 
 Id EmitLoadSharedS16(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 2);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};
         return ctx.OpSConvert(ctx.U32[1], ctx.OpLoad(ctx.U16, pointer));
@@ -73,6 +77,7 @@ Id EmitLoadSharedS16(EmitContext& ctx, Id offset) {
 }
 
 Id EmitLoadSharedU32(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 4);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u32, ctx.shared_memory_u32, offset, 2)};
         return ctx.OpLoad(ctx.U32[1], pointer);
@@ -82,6 +87,7 @@ Id EmitLoadSharedU32(EmitContext& ctx, Id offset) {
 }
 
 Id EmitLoadSharedU64(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 8);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u32x2, ctx.shared_memory_u32x2, offset, 3)};
         return ctx.OpLoad(ctx.U32[2], pointer);
@@ -97,6 +103,7 @@ Id EmitLoadSharedU64(EmitContext& ctx, Id offset) {
 }
 
 Id EmitLoadSharedU128(EmitContext& ctx, Id offset) {
+    offset = ctx.BoundSharedOffset(offset, 16);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u32x4, ctx.shared_memory_u32x4, offset, 4)};
         return ctx.OpLoad(ctx.U32[4], pointer);
@@ -113,6 +120,7 @@ Id EmitLoadSharedU128(EmitContext& ctx, Id offset) {
 }
 
 void EmitWriteSharedU8(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 1);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{
             ctx.OpAccessChain(ctx.shared_u8, ctx.shared_memory_u8, ctx.u32_zero_value, offset)};
@@ -123,6 +131,7 @@ void EmitWriteSharedU8(EmitContext& ctx, Id offset, Id value) {
 }
 
 void EmitWriteSharedU16(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 2);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u16, ctx.shared_memory_u16, offset, 1)};
         ctx.OpStore(pointer, ctx.OpUConvert(ctx.U16, value));
@@ -132,6 +141,7 @@ void EmitWriteSharedU16(EmitContext& ctx, Id offset, Id value) {
 }
 
 void EmitWriteSharedU32(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 4);
     Id pointer{};
     if (ctx.uses_explicit_workgroup_layout) {
         pointer = Pointer(ctx, ctx.shared_u32, ctx.shared_memory_u32, offset, 2);
@@ -144,6 +154,7 @@ void EmitWriteSharedU32(EmitContext& ctx, Id offset, Id value) {
 }
 
 void EmitWriteSharedU64(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 8);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u32x2, ctx.shared_memory_u32x2, offset, 3)};
         ctx.OpStore(pointer, value);
@@ -159,6 +170,7 @@ void EmitWriteSharedU64(EmitContext& ctx, Id offset, Id value) {
 }
 
 void EmitWriteSharedU128(EmitContext& ctx, Id offset, Id value) {
+    offset = ctx.BoundSharedOffset(offset, 16);
     if (ctx.uses_explicit_workgroup_layout) {
         const Id pointer{Pointer(ctx, ctx.shared_u32x4, ctx.shared_memory_u32x4, offset, 4)};
         ctx.OpStore(pointer, value);

src/shader_recompiler/backend/spirv/spirv_emit_context.cpp

@@ -600,6 +600,16 @@ void EmitContext::DefineLocalMemory(const IR::Program& program) {
     }
 }
 
+Id EmitContext::BoundSharedOffset(Id offset, u32 access_bytes) {
+    if (shared_memory_declared_bytes == 0) {
+        return offset;
+    }
+    const u32 last_valid{shared_memory_declared_bytes > access_bytes
+                             ? shared_memory_declared_bytes - access_bytes
+                             : 0U};
+    return OpUMin(U32[1], offset, Const(last_valid));
+}
+
 void EmitContext::DefineSharedMemory(const IR::Program& program) {
     uses_explicit_workgroup_layout =
         profile.support_explicit_workgroup_layout &&
@@ -608,8 +618,15 @@ void EmitContext::DefineSharedMemory(const IR::Program& program) {
     if (program.shared_memory_size == 0) {
         return;
     }
+    const u32 device_limit{profile.max_shared_memory_size};
+    const u32 shared_memory_size{device_limit != 0 && program.shared_memory_size > device_limit
+                                     ? device_limit
+                                     : program.shared_memory_size};
+    if (shared_memory_size != program.shared_memory_size) {
+        shared_memory_declared_bytes = shared_memory_size;
+    }
     const auto make{[&](Id element_type, u32 element_size) {
-        const u32 num_elements{Common::DivCeil(program.shared_memory_size, element_size)};
+        const u32 num_elements{Common::DivCeil(shared_memory_size, element_size)};
         const Id array_type{TypeArray(element_type, Const(num_elements))};
         Decorate(array_type, spv::Decoration::ArrayStride, element_size);
 
@@ -644,7 +661,7 @@ void EmitContext::DefineSharedMemory(const IR::Program& program) {
         std::tie(shared_memory_u32x4, shared_u32x4, std::ignore) = make(U32[4], 16);
         return;
     }
-    const u32 num_elements{Common::DivCeil(program.shared_memory_size, 4U)};
+    const u32 num_elements{Common::DivCeil(shared_memory_size, 4U)};
     const Id type{TypeArray(U32[1], Const(num_elements))};
     shared_memory_u32_type = TypePointer(spv::StorageClass::Workgroup, type);
 

src/shader_recompiler/backend/spirv/spirv_emit_context.h

@@ -312,6 +312,8 @@ public:
     Id local_memory{};
 
     bool uses_explicit_workgroup_layout{};
+    u32 shared_memory_declared_bytes{};
+    [[nodiscard]] Id BoundSharedOffset(Id offset, u32 access_bytes);
     Id shared_memory_u8{};
     Id shared_memory_u16{};
     Id shared_memory_u32{};

src/shader_recompiler/profile.h

@@ -101,6 +101,9 @@ struct Profile {
 
     u32 gl_max_compute_smem_size{};
 
+    /// Largest workgroup shared memory allocation the device accepts, 0 when unconstrained
+    u32 max_shared_memory_size{};
+
     /// Maxwell and earlier nVidia architectures have broken robust support
     bool has_broken_robust{};
 

src/video_core/buffer_cache/buffer_cache.h

@@ -571,7 +571,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>
@@ -579,6 +583,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;
     }
@@ -638,27 +643,84 @@ 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.FlushUnifiedMemoryCopies();
+            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>
@@ -673,32 +735,49 @@ void BufferCache<P>::PopAsyncFlushes() {
 
 template <class P>
 void BufferCache<P>::PopAsyncBuffers() {
-    if (async_buffers.empty()) {
-        return;
-    }
-    if (!async_buffers.front().has_value()) {
+    struct Writeback {
+        DAddr addr;
+        const u8* src;
+        u64 size;
+    };
+    boost::container::small_vector<Writeback, 8> writebacks;
+    {
+        std::scoped_lock lock{mutex};
+        if (async_buffers.empty()) {
+            return;
+        }
+        auto& batch = pending_downloads.front();
+        auto& async_buffer = async_buffers.front();
+        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);
+            async_downloads.Subtract(device_addr, copy.size, [&](DAddr start, DAddr end) {
+                gpu_modified_ranges.Subtract(start, end - start);
+            });
+        }
         async_buffers.pop_front();
-        return;
+        pending_downloads.pop_front();
     }
-    auto& downloads = pending_downloads.front();
-    auto& async_buffer = async_buffers.front();
-    u8* base = async_buffer->mapped_span.data();
-    const size_t base_offset = async_buffer->offset;
-    for (const auto& copy : downloads) {
-        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) {
-            device_memory.WriteBlockUnsafe(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);
-        });
+    for (const auto& wb : writebacks) {
+        device_memory.WriteBlockUnsafe(wb.addr, wb.src, wb.size);
     }
-    async_buffers_death_ring.emplace_back(*async_buffer);
-    async_buffers.pop_front();
-    pending_downloads.pop_front();
 }
 
 template <class P>
@@ -1699,6 +1778,99 @@ void BufferCache<P>::ImmediateUploadMemory([[maybe_unused]] Buffer& buffer,
     }
 }
 
+template <class P>
+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;
+        }
+        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) {
+                    return groups[i];
+                }
+            }
+            window_ids.push_back(window);
+            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) {
+            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<const BufferCopy> group_span(groups[i].data(), groups[i].size());
+            runtime.CopyToUnifiedMemory(window_ids[i], buffer, group_span);
+        }
+        runtime.FlushUnifiedMemoryCopies();
+        runtime.UnifiedMemoryHostBarrier();
+        runtime.Finish();
+        return true;
+    } else {
+        return false;
+    }
+}
+
 template <class P>
 void BufferCache<P>::MappedUploadMemory([[maybe_unused]] Buffer& buffer,
                                         [[maybe_unused]] u64 total_size_bytes,
@@ -1802,6 +1974,12 @@ void BufferCache<P>::DownloadBufferMemory(Buffer& buffer, DAddr device_addr, u64
     }
 
     if constexpr (USE_MEMORY_MAPS) {
+        if constexpr (USE_UNIFIED_MEMORY) {
+            if (runtime.HasUnifiedMemory() &&
+                TryUnifiedDownloadMemory(buffer, std::span(copies.data(), copies.size()))) {
+                return;
+            }
+        }
         auto download_staging = runtime.DownloadStagingBuffer(total_size_bytes);
         const u8* const mapped_memory = download_staging.mapped_span.data();
         const std::span<BufferCopy> copies_span(copies.data(), copies.data() + copies.size());

src/video_core/buffer_cache/buffer_cache_base.h

@@ -180,6 +180,7 @@ class BufferCache : public VideoCommon::ChannelSetupCaches<BufferCacheChannelInf
     static constexpr bool USE_MEMORY_MAPS = P::USE_MEMORY_MAPS;
     static constexpr bool SEPARATE_IMAGE_BUFFERS_BINDINGS = P::SEPARATE_IMAGE_BUFFER_BINDINGS;
     static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = P::USE_MEMORY_MAPS_FOR_UPLOADS;
+    static constexpr bool USE_UNIFIED_MEMORY = P::USE_UNIFIED_MEMORY;
 
 #ifdef YUZU_LEGACY
     static constexpr s64 TARGET_THRESHOLD = 3_GiB;
@@ -443,6 +444,15 @@ private:
 
     void MappedUploadMemory(Buffer& buffer, u64 total_size_bytes, std::span<BufferCopy> copies);
 
+    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);
@@ -498,9 +508,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_opengl/gl_buffer_cache.h

@@ -261,6 +261,7 @@ struct BufferCacheParams {
 
     // TODO: Investigate why OpenGL seems to perform worse with persistently mapped buffer uploads
     static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = false;
+    static constexpr bool USE_UNIFIED_MEMORY = false;
 };
 
 using BufferCache = VideoCommon::BufferCache<BufferCacheParams>;

src/video_core/renderer_opengl/gl_shader_cache.cpp

@@ -237,6 +237,7 @@ ShaderCache::ShaderCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
           .has_gl_bool_ref_bug = device.HasBoolRefBug(),
           .ignore_nan_fp_comparisons = true,
           .gl_max_compute_smem_size = device.GetMaxComputeSharedMemorySize(),
+          .max_shared_memory_size = device.GetMaxComputeSharedMemorySize(),
           .min_ssbo_alignment = device.GetShaderStorageBufferAlignment(),
           // Use the host limit, but never more than the guest can produce. Maxwell exposes 8 clip
           // distances and the SPIR-V output array is sized for at most 8, so clamping here keeps a

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -8,6 +8,7 @@
 #include <array>
 #include <cstring>
 #include <span>
+#include <utility>
 #include <vector>
 
 #include "video_core/buffer_cache/buffer_cache_base.h"
@@ -32,6 +33,32 @@ VkBufferCopy MakeBufferCopy(const VideoCommon::BufferCopy& copy) {
     };
 }
 
+constexpr size_t MAX_WINDOW_BARRIER_RANGES = 8;
+
+using WindowRange = std::pair<VkDeviceSize, VkDeviceSize>;
+using WindowRanges = boost::container::small_vector<WindowRange, MAX_WINDOW_BARRIER_RANGES>;
+
+void CoalesceWindowRanges(WindowRanges& ranges) {
+    if (ranges.size() < 2) {
+        return;
+    }
+    std::sort(ranges.begin(), ranges.end());
+    size_t merged = 0;
+    for (size_t index = 1; index < ranges.size(); ++index) {
+        if (ranges[index].first <= ranges[merged].second) {
+            ranges[merged].second = (std::max)(ranges[merged].second, ranges[index].second);
+        } else {
+            ranges[++merged] = ranges[index];
+        }
+    }
+    ranges.resize(merged + 1);
+    if (ranges.size() > MAX_WINDOW_BARRIER_RANGES) {
+        const WindowRange bounding{ranges.front().first, ranges.back().second};
+        ranges.clear();
+        ranges.push_back(bounding);
+    }
+}
+
 VkIndexType IndexTypeFromNumElements(const Device& device, u32 num_elements) {
     if (num_elements <= 0xff && device.IsExtIndexTypeUint8Supported()) {
         return VK_INDEX_TYPE_UINT8_EXT;
@@ -365,6 +392,141 @@ BufferCacheRuntime::BufferCacheRuntime(const Device& device_, MemoryAllocator& m
                                                                      scheduler_, staging_pool_);
 }
 
+void BufferCacheRuntime::TryEnableUnifiedMemory(void* base, size_t size,
+                                                std::span<AHardwareBuffer* const> hardware_buffers,
+                                                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() ||
+        unified_memory->GetWindowBuffer(window_index) == VK_NULL_HANDLE) {
+        return;
+    }
+    PendingUnifiedCopy& pending = pending_unified_copies.emplace_back();
+    pending.window = window_index;
+    pending.buffer = src_buffer;
+    pending.copies.resize(copies.size());
+    std::ranges::transform(copies, pending.copies.begin(), MakeBufferCopy);
+}
+
+void BufferCacheRuntime::FlushUnifiedMemoryCopies() {
+    if (pending_unified_copies.empty()) {
+        return;
+    }
+    struct UnifiedCopyCommand {
+        VkBuffer buffer;
+        boost::container::small_vector<VkBufferCopy, 8> copies;
+    };
+
+    std::stable_sort(pending_unified_copies.begin(), pending_unified_copies.end(),
+                     [](const PendingUnifiedCopy& lhs, const PendingUnifiedCopy& rhs) {
+                         return lhs.window < rhs.window;
+                     });
+
+    const bool foreign = unified_memory->NeedsForeignOwnershipTransfer();
+    const u32 queue_family = device.GetGraphicsFamily();
+
+    size_t group_begin = 0;
+    while (group_begin < pending_unified_copies.size()) {
+        const size_t window = pending_unified_copies[group_begin].window;
+        size_t group_end = group_begin;
+        while (group_end < pending_unified_copies.size() &&
+               pending_unified_copies[group_end].window == window) {
+            ++group_end;
+        }
+        const VkBuffer window_buffer = unified_memory->GetWindowBuffer(window);
+
+        WindowRanges ranges;
+        for (size_t index = group_begin; index < group_end; ++index) {
+            for (const VkBufferCopy& copy : pending_unified_copies[index].copies) {
+                ranges.emplace_back(copy.dstOffset, copy.dstOffset + copy.size);
+            }
+        }
+        CoalesceWindowRanges(ranges);
+
+        boost::container::small_vector<VkBufferMemoryBarrier, MAX_WINDOW_BARRIER_RANGES> acquire;
+        boost::container::small_vector<VkBufferMemoryBarrier, MAX_WINDOW_BARRIER_RANGES> release;
+        if (foreign) {
+            for (const WindowRange& range : ranges) {
+                acquire.push_back(VkBufferMemoryBarrier{
+                    .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 = window_buffer,
+                    .offset = range.first,
+                    .size = range.second - range.first,
+                });
+                release.push_back(VkBufferMemoryBarrier{
+                    .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 = window_buffer,
+                    .offset = range.first,
+                    .size = range.second - range.first,
+                });
+            }
+        }
+
+        boost::container::small_vector<UnifiedCopyCommand, 4> commands;
+        commands.reserve(group_end - group_begin);
+        for (size_t index = group_begin; index < group_end; ++index) {
+            PendingUnifiedCopy& pending = pending_unified_copies[index];
+            commands.push_back(UnifiedCopyCommand{pending.buffer, std::move(pending.copies)});
+        }
+
+        scheduler.RequestOutsideRenderPassOperationContext();
+        scheduler.Record([window_buffer, acquire = std::move(acquire), release = std::move(release),
+                          commands = std::move(commands)](vk::CommandBuffer cmdbuf) {
+            if (!acquire.empty()) {
+                cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
+                                       VK_PIPELINE_STAGE_TRANSFER_BIT, 0, {},
+                                       VideoCommon::FixSmallVectorADL(acquire), {});
+            }
+            for (const UnifiedCopyCommand& command : commands) {
+                cmdbuf.CopyBuffer(command.buffer, window_buffer,
+                                  VideoCommon::FixSmallVectorADL(command.copies));
+            }
+            if (!release.empty()) {
+                cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
+                                       VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, 0, {},
+                                       VideoCommon::FixSmallVectorADL(release), {});
+            }
+        });
+
+        group_begin = group_end;
+    }
+    pending_unified_copies.clear();
+}
+
+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);
 }
@@ -402,6 +564,7 @@ u32 BufferCacheRuntime::GetStorageBufferAlignment() const {
 }
 
 void BufferCacheRuntime::TickFrame(Common::SlotVector<Buffer>& slot_buffers) noexcept {
+    FlushUnifiedMemoryCopies();
     for (auto it = slot_buffers.begin(); it != slot_buffers.end(); it++) {
         if (scheduler.IsFree(it->LastUsageTick())) {
             it->ResetUsageTracking();

src/video_core/renderer_vulkan/vk_buffer_cache.h

@@ -7,6 +7,10 @@
 #pragma once
 
 #include <limits>
+#include <memory>
+#include <span>
+
+#include <boost/container/small_vector.hpp>
 
 #include "video_core/buffer_cache/buffer_cache_base.h"
 #include "video_core/buffer_cache/memory_tracker_base.h"
@@ -97,6 +101,33 @@ public:
 
     void TickFrame(Common::SlotVector<Buffer>& slot_buffers) noexcept;
 
+    void TryEnableUnifiedMemory(void* base, size_t size,
+                                std::span<AHardwareBuffer* const> hardware_buffers,
+                                size_t hardware_buffer_window, size_t hardware_buffer_base);
+
+    [[nodiscard]] bool HasUnifiedMemory() const noexcept {
+        return unified_memory != nullptr && unified_memory->IsValid();
+    }
+
+    [[nodiscard]] u64 UnifiedMemorySize() const noexcept {
+        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;
+    }
+
+    void CopyToUnifiedMemory(size_t window_index, VkBuffer src_buffer,
+                             std::span<const VideoCommon::BufferCopy> copies);
+
+    void FlushUnifiedMemoryCopies();
+
+    void UnifiedMemoryHostBarrier();
+
     u64 CurrentTick();
 
     u64 KnownGpuTick();
@@ -180,6 +211,12 @@ public:
     }
 
 private:
+    struct PendingUnifiedCopy {
+        size_t window;
+        VkBuffer buffer;
+        boost::container::small_vector<VkBufferCopy, 8> copies;
+    };
+
     void BindBuffer(const Buffer& buffer, u32 offset, u32 size) {
         const VkBuffer handle = buffer.Handle();
         if (handle == VK_NULL_HANDLE) {
@@ -204,6 +241,8 @@ private:
     std::shared_ptr<QuadStripIndexBuffer> quad_strip_index_buffer;
 
     vk::Buffer null_buffer;
+    std::unique_ptr<HostMemoryImport> unified_memory;
+    boost::container::small_vector<PendingUnifiedCopy, 8> pending_unified_copies;
 
     std::unique_ptr<Uint8Pass> uint8_pass;
     QuadIndexedPass quad_index_pass;
@@ -226,6 +265,7 @@ struct BufferCacheParams {
     static constexpr bool USE_MEMORY_MAPS = true;
     static constexpr bool SEPARATE_IMAGE_BUFFER_BINDINGS = false;
     static constexpr bool USE_MEMORY_MAPS_FOR_UPLOADS = true;
+    static constexpr bool USE_UNIFIED_MEMORY = true;
 };
 
 using BufferCache = VideoCommon::BufferCache<BufferCacheParams>;

src/video_core/renderer_vulkan/vk_pipeline_cache.cpp

@@ -446,6 +446,7 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
         .has_broken_fp16_float_controls = driver_id == VK_DRIVER_ID_NVIDIA_PROPRIETARY,
         .ignore_nan_fp_comparisons = false,
         .has_broken_spirv_subgroup_mask_vector_extract_dynamic = false,
+        .max_shared_memory_size = device.GetMaxComputeSharedMemorySize(),
         .has_broken_robust =
             device.IsNvidia() && device.GetNvidiaArch() <= NvidiaArchitecture::Arch_Pascal,
         .min_ssbo_alignment = device.GetStorageBufferAlignment(),
@@ -921,19 +922,6 @@ std::unique_ptr<ComputePipeline> PipelineCache::CreateComputePipeline(
     }
 
     auto program{TranslateProgram(pools.inst, pools.block, env, cfg, host_info)};
-    const VkDriverIdKHR driver_id = device.GetDriverID();
-    const bool needs_shared_mem_clamp =
-        driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY ||
-        driver_id == VK_DRIVER_ID_ARM_PROPRIETARY;
-    const u32 max_shared_memory = device.GetMaxComputeSharedMemorySize();
-    if (needs_shared_mem_clamp && program.shared_memory_size > max_shared_memory) {
-        LOG_WARNING(Render_Vulkan,
-                    "Compute shader {:#016x} requests {}KB shared memory but device max is {}KB - clamping",
-                    key.unique_hash,
-                    program.shared_memory_size / 1024,
-                    max_shared_memory / 1024);
-        program.shared_memory_size = max_shared_memory;
-    }
     const std::vector<u32> code{EmitSPIRV(profile, program)};
     device.SaveShader(code);
     vk::ShaderModule spv_module{BuildShader(device, code)};

src/video_core/renderer_vulkan/vk_rasterizer.cpp

@@ -225,6 +225,13 @@ 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() && device_memory.IsBackingShared()) {
+        buffer_cache_runtime.TryEnableUnifiedMemory(
+            device_memory.GetPhysicalBase(), device_memory.GetPhysicalSize(),
+            device_memory.GetBackingHardwareBuffers(),
+            device_memory.GetBackingHardwareBufferWindowSize(),
+            device_memory.GetBackingHardwareBufferBase());
+    }
 }
 
 RasterizerVulkan::~RasterizerVulkan() {

src/video_core/vulkan_common/vulkan_device.cpp

@@ -16,6 +16,7 @@
 #include <fmt/format.h>
 
 #include "common/assert.h"
+#include "common/host_memory.h"
 #include "common/literals.h"
 #include <ranges>
 #include "common/settings.h"
@@ -974,6 +975,7 @@ bool Device::GetSuitability(bool requires_swapchain) {
 
     FOR_EACH_VK_FEATURE_EXT(FEATURE_EXTENSION);
     FOR_EACH_VK_EXTENSION(EXTENSION);
+    FOR_EACH_VK_PLATFORM_EXTENSION(EXTENSION);
 
     if (supported_extensions.contains(VK_KHR_ROBUSTNESS_2_EXTENSION_NAME)) {
         loaded_extensions.erase(VK_EXT_ROBUSTNESS_2_EXTENSION_NAME);
@@ -986,6 +988,13 @@ bool Device::GetSuitability(bool requires_swapchain) {
         extensions.robustness_2 = false;
     }
 
+#ifdef __ANDROID__
+    if (extensions.external_memory_ahb && !extensions.queue_family_foreign) {
+        loaded_extensions.erase(VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME);
+        extensions.external_memory_ahb = false;
+    }
+#endif
+
 #undef FEATURE_EXTENSION
 #undef EXTENSION
 
@@ -1142,6 +1151,21 @@ bool Device::GetSuitability(bool requires_swapchain) {
             VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR;
         SetNext(next, properties.maintenance5);
     }
+    if (extensions.external_memory_host) {
+        properties.external_memory_host.sType =
+            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;
+        SetNext(next, properties.maintenance4);
+    }
 
     // Perform the property fetch.
     physical.GetProperties2(properties2);
@@ -1516,12 +1540,27 @@ void Device::CollectPhysicalMemoryInfo() {
     device_access_memory = 0;
     u64 device_initial_usage = 0;
     u64 local_memory = 0;
+    const auto heap_has_usable_type = [&mem_properties](size_t heap) {
+        for (u32 index = 0; index < mem_properties.memoryTypeCount; ++index) {
+            if (mem_properties.memoryTypes[index].heapIndex != heap) {
+                continue;
+            }
+            if ((mem_properties.memoryTypes[index].propertyFlags &
+                 VK_MEMORY_PROPERTY_PROTECTED_BIT) == 0) {
+                return true;
+            }
+        }
+        return false;
+    };
     for (size_t element = 0; element < num_properties; ++element) {
         const bool is_heap_local =
             (mem_properties.memoryHeaps[element].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) != 0;
         if (!is_integrated && !is_heap_local) {
             continue;
         }
+        if (!heap_has_usable_type(element)) {
+            continue;
+        }
         valid_heap_memory.push_back(element);
         if (is_heap_local) {
             local_memory += mem_properties.memoryHeaps[element].size;
@@ -1533,6 +1572,13 @@ void Device::CollectPhysicalMemoryInfo() {
         }
         device_access_memory += mem_properties.memoryHeaps[element].size;
     }
+    const u64 committed_backing = Common::GetCommittedBackingSize();
+    if (committed_backing != 0) {
+        LOG_INFO(Render_Vulkan, "Discounting {} MiB of guest memory committed by the host",
+                 committed_backing >> 20);
+        local_memory -= std::min(local_memory, committed_backing);
+        device_access_memory -= std::min(device_access_memory, committed_backing);
+    }
     if (is_integrated) {
         const s64 available_memory = static_cast<s64>(device_access_memory - device_initial_usage);
         const u64 memory_size = Settings::values.vram_usage_mode.GetValue() == Settings::VramUsageMode::Aggressive ? 6_GiB : 4_GiB;

src/video_core/vulkan_common/vulkan_device.h

@@ -83,6 +83,7 @@ VK_DEFINE_HANDLE(VmaAllocator)
     EXTENSION(EXT, CONDITIONAL_RENDERING, conditional_rendering)                                   \
     EXTENSION(EXT, CONSERVATIVE_RASTERIZATION, conservative_rasterization)                         \
     EXTENSION(EXT, DEPTH_RANGE_UNRESTRICTED, depth_range_unrestricted)                             \
+    EXTENSION(EXT, EXTERNAL_MEMORY_HOST, external_memory_host)                                     \
     EXTENSION(EXT, MEMORY_BUDGET, memory_budget)                                                   \
     EXTENSION(EXT, ROBUSTNESS_2, robustness_2)                                                     \
     EXTENSION(EXT, SAMPLER_FILTER_MINMAX, sampler_filter_minmax)                                   \
@@ -112,6 +113,14 @@ VK_DEFINE_HANDLE(VmaAllocator)
     EXTENSION(IMG, FILTER_CUBIC, filter_cubic_img)                                                 \
     EXTENSION(QCOM, FILTER_CUBIC_WEIGHTS, filter_cubic_weights)
 
+#ifdef __ANDROID__
+#define FOR_EACH_VK_PLATFORM_EXTENSION(EXTENSION)                                                  \
+    EXTENSION(EXT, QUEUE_FAMILY_FOREIGN, queue_family_foreign)                                     \
+    EXTENSION(ANDROID, EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER, external_memory_ahb)
+#else
+#define FOR_EACH_VK_PLATFORM_EXTENSION(EXTENSION)
+#endif
+
 // Define extensions which must be supported.
 #define FOR_EACH_VK_MANDATORY_EXTENSION(EXTENSION_NAME)                                            \
     EXTENSION_NAME(VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME)                                 \
@@ -838,6 +847,30 @@ FN_MAX_LIMIT_LIST
         return extensions.conditional_rendering;
     }
 
+    bool IsExtExternalMemoryHostSupported() const {
+        return extensions.external_memory_host;
+    }
+
+    bool IsExtExternalMemoryAhbSupported() const {
+#ifdef __ANDROID__
+        return extensions.external_memory_ahb && extensions.queue_family_foreign;
+#else
+        return false;
+#endif
+    }
+
+    u64 GetMinImportedHostPointerAlignment() const {
+        return properties.external_memory_host.minImportedHostPointerAlignment;
+    }
+
+    u64 GetMaxBufferSize() const {
+        return properties.maintenance4.maxBufferSize;
+    }
+
+    u64 GetMaxMemoryAllocationSize() const {
+        return properties.maintenance3.maxMemoryAllocationSize;
+    }
+
     bool IsExtAstcDecodeModeSupported() const {
         return extensions.astc_decode_mode;
     }
@@ -1110,6 +1143,7 @@ private:
         FOR_EACH_VK_FEATURE_1_4(FEATURE);
         FOR_EACH_VK_FEATURE_EXT(FEATURE);
         FOR_EACH_VK_EXTENSION(EXTENSION);
+        FOR_EACH_VK_PLATFORM_EXTENSION(EXTENSION);
 
 #undef EXTENSION
 #undef FEATURE
@@ -1141,7 +1175,10 @@ private:
         VkPhysicalDeviceDescriptorBufferPropertiesEXT descriptor_buffer{};
         VkPhysicalDeviceSubgroupSizeControlProperties subgroup_size_control{};
         VkPhysicalDeviceTransformFeedbackPropertiesEXT transform_feedback{};
+        VkPhysicalDeviceMaintenance3Properties maintenance3{};
+        VkPhysicalDeviceMaintenance4Properties maintenance4{};
         VkPhysicalDeviceMaintenance5PropertiesKHR maintenance5{};
+        VkPhysicalDeviceExternalMemoryHostPropertiesEXT external_memory_host{};
 
         VkPhysicalDeviceProperties properties{};
     };

src/video_core/vulkan_common/vulkan_memory_allocator.cpp

@@ -25,9 +25,34 @@
 #include "video_core/gpu_logging/gpu_logging.h"
 #include "common/settings.h"
 
+#ifdef __ANDROID__
+#include <android/hardware_buffer.h>
+#endif
+
 namespace Vulkan {
     namespace {
 
+        [[nodiscard]] std::optional<u32> FindImportMemoryType(
+                const VkPhysicalDeviceMemoryProperties &props, u32 type_mask) {
+            const auto find = [&](VkMemoryPropertyFlags wanted) -> std::optional<u32> {
+                for (u32 i = 0; i < props.memoryTypeCount; ++i) {
+                    if (((type_mask >> i) & 1u) != 0 &&
+                        (props.memoryTypes[i].propertyFlags & wanted) == wanted) {
+                        return i;
+                    }
+                }
+                return std::nullopt;
+            };
+            auto type_index = find(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+                                   VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
+                                   VK_MEMORY_PROPERTY_HOST_CACHED_BIT);
+            if (!type_index) {
+                type_index = find(VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
+                                  VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
+            }
+            return type_index;
+        }
+
 // Helpers translating MemoryUsage to flags/usage
 
         [[maybe_unused]] VkMemoryPropertyFlags MemoryUsagePropertyFlags(MemoryUsage usage) {
@@ -200,6 +225,263 @@ namespace Vulkan {
         size = 0;
     }
 
+    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_base)
+            : device{device_} {
+        if (ImportHardwareBuffers(hardware_buffers, hardware_buffer_window, hardware_buffer_base,
+                                  size)) {
+            return;
+        }
+        if (device.IsTiler()) {
+            return;
+        }
+        if (!hardware_buffers.empty()) {
+            return;
+        }
+        if (ImportHostPointer(base, size)) {
+            return;
+        }
+        LOG_INFO(Render_Vulkan, "Unified memory disabled, no host memory import path");
+    }
+
+    bool HostMemoryImport::ImportHostPointer(void *base, size_t size) {
+        if (!device.IsExtExternalMemoryHostSupported()) {
+            return false;
+        }
+        const u64 alignment = device.GetMinImportedHostPointerAlignment();
+        if (alignment == 0 || !Common::IsAligned(reinterpret_cast<uintptr_t>(base), alignment) ||
+            !Common::IsAligned(size, alignment)) {
+            return false;
+        }
+        using namespace Common::Literals;
+        constexpr VkDeviceSize DesktopWindowSize = 4_GiB;
+        VkDeviceSize candidate_window = DesktopWindowSize;
+        const u64 max_buffer_size = device.GetMaxBufferSize();
+        if (max_buffer_size != 0 && max_buffer_size < candidate_window) {
+            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;
+        }
+        window_size = candidate_window;
+
+        const auto &logical = device.GetLogical();
+        const auto memory_props = device.GetPhysical().GetMemoryProperties().memoryProperties;
+
+        for (size_t offset = 0; offset < size; offset += window_size) {
+            u8 *const window_base = static_cast<u8 *>(base) + offset;
+            const VkDeviceSize window_len =
+                    (std::min)(static_cast<VkDeviceSize>(size - offset), window_size);
+            VkMemoryHostPointerPropertiesEXT host_props{
+                    .sType = VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT,
+                    .pNext = nullptr,
+                    .memoryTypeBits = 0,
+            };
+            if (logical.GetMemoryHostPointerPropertiesEXT(
+                        VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT, window_base,
+                        &host_props) != VK_SUCCESS ||
+                host_props.memoryTypeBits == 0) {
+                break;
+            }
+            const VkExternalMemoryBufferCreateInfo external_info{
+                    .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
+                    .pNext = nullptr,
+                    .handleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
+            };
+            const VkBufferCreateInfo buffer_ci{
+                    .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+                    .pNext = &external_info,
+                    .flags = 0,
+                    .size = window_len,
+                    .usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+                    .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
+                    .queueFamilyIndexCount = 0,
+                    .pQueueFamilyIndices = nullptr,
+            };
+            VkBuffer new_buffer{};
+            if (logical.CreateBufferRaw(buffer_ci, &new_buffer) != VK_SUCCESS) {
+                break;
+            }
+            const VkMemoryRequirements requirements =
+                    logical.GetBufferMemoryRequirements(new_buffer);
+            const u32 type_mask = requirements.memoryTypeBits & host_props.memoryTypeBits;
+            if (type_mask == 0 || requirements.size > window_len) {
+                logical.DestroyBufferRaw(new_buffer);
+                break;
+            }
+            const auto type_index = FindImportMemoryType(memory_props, type_mask);
+            if (!type_index) {
+                logical.DestroyBufferRaw(new_buffer);
+                break;
+            }
+            const u32 heap_index = memory_props.memoryTypes[*type_index].heapIndex;
+            const VkDeviceSize heap_size = memory_props.memoryHeaps[heap_index].size;
+            if (imported_size + window_len > heap_size / 2) {
+                logical.DestroyBufferRaw(new_buffer);
+                break;
+            }
+            const VkImportMemoryHostPointerInfoEXT import_info{
+                    .sType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT,
+                    .pNext = nullptr,
+                    .handleType = VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT,
+                    .pHostPointer = window_base,
+            };
+            const VkMemoryAllocateInfo alloc_info{
+                    .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+                    .pNext = &import_info,
+                    .allocationSize = window_len,
+                    .memoryTypeIndex = *type_index,
+            };
+            vk::DeviceMemory memory = logical.TryAllocateMemory(alloc_info);
+            if (!memory) {
+                logical.DestroyBufferRaw(new_buffer);
+                break;
+            }
+            if (logical.BindBufferMemory(new_buffer, *memory, 0) != VK_SUCCESS) {
+                logical.DestroyBufferRaw(new_buffer);
+                break;
+            }
+            windows.push_back(Window{
+                    .memory = std::move(memory),
+                    .buffer = new_buffer,
+            });
+            imported_size += static_cast<size_t>(window_len);
+        }
+        if (windows.empty()) {
+            return false;
+        }
+        return true;
+    }
+
+    bool HostMemoryImport::ImportHardwareBuffers(
+            [[maybe_unused]] std::span<AHardwareBuffer *const> hardware_buffers,
+            [[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 false;
+        }
+        const u64 max_allocation_size = device.GetMaxMemoryAllocationSize();
+        if (max_allocation_size != 0 && hardware_buffer_window > max_allocation_size) {
+            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 = hardware_buffer_base + i * hardware_buffer_window;
+            if (offset >= size) {
+                break;
+            }
+            const VkDeviceSize window_len = (std::min)(
+                    static_cast<VkDeviceSize>(size - offset),
+                    static_cast<VkDeviceSize>(hardware_buffer_window));
+            VkAndroidHardwareBufferPropertiesANDROID ahb_props{
+                    .sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID,
+                    .pNext = nullptr,
+                    .allocationSize = 0,
+                    .memoryTypeBits = 0,
+            };
+            if (logical.GetAndroidHardwareBufferPropertiesANDROID(hardware_buffers[i],
+                                                                  &ahb_props) != VK_SUCCESS ||
+                ahb_props.memoryTypeBits == 0 || ahb_props.allocationSize < window_len) {
+                break;
+            }
+            const VkExternalMemoryBufferCreateInfo external_info{
+                    .sType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
+                    .pNext = nullptr,
+                    .handleTypes =
+                            VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID,
+            };
+            const VkBufferCreateInfo buffer_ci{
+                    .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
+                    .pNext = &external_info,
+                    .flags = 0,
+                    .size = window_len,
+                    .usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT | VK_BUFFER_USAGE_TRANSFER_DST_BIT,
+                    .sharingMode = VK_SHARING_MODE_EXCLUSIVE,
+                    .queueFamilyIndexCount = 0,
+                    .pQueueFamilyIndices = nullptr,
+            };
+            VkBuffer new_buffer{};
+            if (logical.CreateBufferRaw(buffer_ci, &new_buffer) != VK_SUCCESS) {
+                break;
+            }
+            const VkMemoryRequirements requirements =
+                    logical.GetBufferMemoryRequirements(new_buffer);
+            const u32 type_mask = requirements.memoryTypeBits & ahb_props.memoryTypeBits;
+            if (type_mask == 0 || requirements.size > ahb_props.allocationSize) {
+                logical.DestroyBufferRaw(new_buffer);
+                break;
+            }
+            const auto type_index = FindImportMemoryType(memory_props, type_mask);
+            if (!type_index) {
+                logical.DestroyBufferRaw(new_buffer);
+                break;
+            }
+            const VkImportAndroidHardwareBufferInfoANDROID import_info{
+                    .sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID,
+                    .pNext = nullptr,
+                    .buffer = hardware_buffers[i],
+            };
+            const VkMemoryDedicatedAllocateInfo dedicated_info{
+                    .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
+                    .pNext = &import_info,
+                    .image = VK_NULL_HANDLE,
+                    .buffer = new_buffer,
+            };
+            const VkMemoryAllocateInfo alloc_info{
+                    .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+                    .pNext = &dedicated_info,
+                    .allocationSize = ahb_props.allocationSize,
+                    .memoryTypeIndex = *type_index,
+            };
+            vk::DeviceMemory memory = logical.TryAllocateMemory(alloc_info);
+            if (!memory) {
+                logical.DestroyBufferRaw(new_buffer);
+                break;
+            }
+            if (logical.BindBufferMemory(new_buffer, *memory, 0) != VK_SUCCESS) {
+                logical.DestroyBufferRaw(new_buffer);
+                break;
+            }
+            windows.push_back(Window{
+                    .memory = std::move(memory),
+                    .buffer = new_buffer,
+            });
+            imported_size += static_cast<size_t>(window_len);
+        }
+        if (windows.empty()) {
+            window_size = 0;
+            base_offset = 0;
+            return false;
+        }
+        foreign_ownership = true;
+        return true;
+#else
+        return false;
+#endif
+    }
+
+    HostMemoryImport::~HostMemoryImport() {
+        for (Window &window : windows) {
+            if (window.buffer != VK_NULL_HANDLE) {
+                device.GetLogical().DestroyBufferRaw(window.buffer);
+            }
+        }
+    }
+
     MemoryAllocator::MemoryAllocator(const Device &device_)
             : device{device_}, allocator{device.GetAllocator()},
               properties{device_.GetPhysical().GetMemoryProperties().memoryProperties},

src/video_core/vulkan_common/vulkan_memory_allocator.h

@@ -15,6 +15,8 @@
 #include "video_core/vulkan_common/vulkan_wrapper.h"
 #include "video_core/vulkan_common/vma.h"
 
+struct AHardwareBuffer;
+
 namespace Vulkan {
 
     class Device;
@@ -84,6 +86,66 @@ namespace Vulkan {
         void *mapped_ptr{};  ///< Optional persistent mapped pointer
     };
 
+    class HostMemoryImport {
+    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_base);
+
+        ~HostMemoryImport();
+
+        HostMemoryImport(const HostMemoryImport &) = delete;
+
+        HostMemoryImport &operator=(const HostMemoryImport &) = delete;
+
+        [[nodiscard]] bool IsValid() const noexcept {
+            return !windows.empty();
+        }
+
+        [[nodiscard]] size_t GetSize() const noexcept {
+            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;
+        }
+
+        [[nodiscard]] VkBuffer GetWindowBuffer(size_t index) const noexcept {
+            return windows[index].buffer;
+        }
+
+        [[nodiscard]] size_t GetWindowCount() const noexcept {
+            return windows.size();
+        }
+
+    private:
+        struct Window {
+            vk::DeviceMemory memory;
+            VkBuffer buffer{};
+        };
+
+        bool ImportHostPointer(void *base, 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.
 /// Allocates and releases memory allocations on demand.
     class MemoryAllocator {

src/video_core/vulkan_common/vulkan_wrapper.cpp

@@ -216,12 +216,16 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept {
     X(vkGetBufferMemoryRequirements2);
     X(vkGetDeviceQueue);
     X(vkGetEventStatus);
+    X(vkGetMemoryHostPointerPropertiesEXT);
     X(vkGetFenceStatus);
     X(vkGetImageMemoryRequirements);
     X(vkGetPipelineCacheData);
     X(vkGetMemoryFdKHR);
 #ifdef _WIN32
     X(vkGetMemoryWin32HandleKHR);
+#endif
+#ifdef __ANDROID__
+    X(vkGetAndroidHardwareBufferPropertiesANDROID);
 #endif
     X(vkGetQueryPoolResults);
     X(vkGetPipelineExecutablePropertiesKHR);

src/video_core/vulkan_common/vulkan_wrapper.h

@@ -332,12 +332,16 @@ struct DeviceDispatch : InstanceDispatch {
     PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2{};
     PFN_vkGetDeviceQueue vkGetDeviceQueue{};
     PFN_vkGetEventStatus vkGetEventStatus{};
+    PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT{};
     PFN_vkGetFenceStatus vkGetFenceStatus{};
     PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements{};
     PFN_vkGetPipelineCacheData vkGetPipelineCacheData{};
     PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR{};
 #ifdef _WIN32
     PFN_vkGetMemoryWin32HandleKHR vkGetMemoryWin32HandleKHR{};
+#endif
+#ifdef __ANDROID__
+    PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID{};
 #endif
     PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR{};
     PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR{};
@@ -1082,6 +1086,34 @@ public:
     VkMemoryRequirements GetBufferMemoryRequirements(VkBuffer buffer,
                                                      void* pnext = nullptr) const noexcept;
 
+    VkResult GetMemoryHostPointerPropertiesEXT(
+        VkExternalMemoryHandleTypeFlagBits handle_type, const void* host_pointer,
+        VkMemoryHostPointerPropertiesEXT* out_properties) const noexcept {
+        return dld->vkGetMemoryHostPointerPropertiesEXT(handle, handle_type, host_pointer,
+                                                        out_properties);
+    }
+
+#ifdef __ANDROID__
+    VkResult GetAndroidHardwareBufferPropertiesANDROID(
+        const struct AHardwareBuffer* buffer,
+        VkAndroidHardwareBufferPropertiesANDROID* out_properties) const noexcept {
+        return dld->vkGetAndroidHardwareBufferPropertiesANDROID(handle, buffer, out_properties);
+    }
+#endif
+
+    VkResult CreateBufferRaw(const VkBufferCreateInfo& ci, VkBuffer* out_buffer) const noexcept {
+        return dld->vkCreateBuffer(handle, &ci, nullptr, out_buffer);
+    }
+
+    void DestroyBufferRaw(VkBuffer buffer) const noexcept {
+        dld->vkDestroyBuffer(handle, buffer, nullptr);
+    }
+
+    VkResult BindBufferMemory(VkBuffer buffer, VkDeviceMemory memory,
+                              VkDeviceSize offset) const noexcept {
+        return dld->vkBindBufferMemory(handle, buffer, memory, offset);
+    }
+
     VkMemoryRequirements GetImageMemoryRequirements(VkImage image) const noexcept;
 
     std::vector<VkPipelineExecutablePropertiesKHR> GetPipelineExecutablePropertiesKHR(