From 73cac64037e8c56591c648e7bd68f25db6908762 Mon Sep 17 00:00:00 2001 From: CamilleLaVey Date: Thu, 1 Oct 2026 16:26:33 -0400 Subject: [PATCH] Port UMA part 5.2 --- src/common/heap_tracker.cpp | 50 +-- src/common/heap_tracker.h | 6 - src/common/host_memory.cpp | 347 +----------------- src/common/host_memory.h | 17 +- src/common/memory_detect.cpp | 64 ---- src/common/memory_detect.h | 7 - src/core/core.cpp | 5 +- src/core/device_memory.cpp | 17 +- .../renderer_vulkan/vk_guest_memory.cpp | 75 +--- .../renderer_vulkan/vk_guest_memory.h | 2 - .../vulkan_common/vulkan_device.cpp | 9 - src/video_core/vulkan_common/vulkan_device.h | 5 - .../vulkan_common/vulkan_wrapper.cpp | 17 - src/video_core/vulkan_common/vulkan_wrapper.h | 8 - 14 files changed, 40 insertions(+), 589 deletions(-) diff --git a/src/common/heap_tracker.cpp b/src/common/heap_tracker.cpp index 1fa1514da7..b72abb16d8 100644 --- a/src/common/heap_tracker.cpp +++ b/src/common/heap_tracker.cpp @@ -4,17 +4,34 @@ // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project // SPDX-License-Identifier: GPL-2.0-or-later +#include #include "common/heap_tracker.h" #include "common/logging.h" -#include "common/memory_detect.h" #include "common/assert.h" namespace Common { +namespace { + +s64 GetMaxPermissibleResidentMapCount() { + // Default value. + s64 value = 65530; + + // Try to read how many mappings we can make. + std::ifstream s("/proc/sys/vm/max_map_count"); + s >> value; + + // Print, for debug. + LOG_INFO(HW_Memory, "Current maximum map count: {}", value); + + // Allow 20000 maps for other code and to account for split inaccuracy. + return std::max(value - 20000, 0); +} + +} // namespace + HeapTracker::HeapTracker(Common::HostMemory& buffer) - : m_buffer(buffer), - m_has_hardware_buffer_backing(!buffer.BackingHardwareBuffers().empty()), - m_max_resident_map_count(static_cast(GetPermissibleMapCount())) {} + : m_buffer(buffer), m_max_resident_map_count(GetMaxPermissibleResidentMapCount()) {} HeapTracker::~HeapTracker() = default; void HeapTracker::Map(size_t virtual_offset, size_t host_offset, size_t length, @@ -68,8 +85,7 @@ void HeapTracker::Unmap(size_t virtual_offset, size_t size, bool is_separate_hea // If resident, erase from resident map. if (item->is_resident) { - m_resident_map_count -= this->HostMapCount(item->paddr, item->size); - ASSERT(m_resident_map_count >= 0); + ASSERT(--m_resident_map_count >= 0); m_resident_mappings.erase(m_resident_mappings.iterator_to(*item)); } @@ -175,7 +191,7 @@ bool HeapTracker::DeferredMapSeparateHeap(size_t virtual_offset) { // This map is now resident. it->is_resident = true; - m_resident_map_count += this->HostMapCount(it->paddr, it->size); + m_resident_map_count++; m_resident_mappings.insert(*it); } @@ -197,17 +213,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. - s64 const desired_count = (std::min)(m_resident_map_count, m_max_resident_map_count) / 2; + 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; auto it = m_resident_mappings.begin(); - while (m_resident_map_count > desired_count && it != m_resident_mappings.end()) { + for (size_t i = 0; i < evict_count && it != m_resident_mappings.end(); i++) { // Unmark and unmap. it->is_resident = false; m_buffer.Unmap(it->vaddr, it->size, false); // Advance. - m_resident_map_count -= this->HostMapCount(it->paddr, it->size); - ASSERT(m_resident_map_count >= 0); + ASSERT(--m_resident_map_count >= 0); it = m_resident_mappings.erase(it); } } @@ -229,7 +245,6 @@ 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; @@ -251,20 +266,11 @@ void HeapTracker::SplitHeapMapLocked(VAddr offset) { // If resident, also insert into resident map. if (right->is_resident) { - m_resident_map_count += this->HostMapCount(left->paddr, left->size) + - this->HostMapCount(right->paddr, right->size) - - orig_host_map_count; + m_resident_map_count++; m_resident_mappings.insert(*right); } } -s64 HeapTracker::HostMapCount(PAddr paddr, size_t size) const { - if (!m_has_hardware_buffer_backing) { - return static_cast(size != 0); - } - return static_cast(m_buffer.BackingMapCount(paddr, size)); -} - HeapTracker::AddrTree::iterator HeapTracker::GetNearestHeapMapLocked(VAddr offset) { const SeparateHeapMap key{ .vaddr = offset, diff --git a/src/common/heap_tracker.h b/src/common/heap_tracker.h index 8be66a1d4d..ee5b0bf43a 100644 --- a/src/common/heap_tracker.h +++ b/src/common/heap_tracker.h @@ -1,6 +1,3 @@ -// 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 @@ -85,13 +82,10 @@ 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{}; diff --git a/src/common/host_memory.cpp b/src/common/host_memory.cpp index 65e73eb5a2..dd0780a283 100644 --- a/src/common/host_memory.cpp +++ b/src/common/host_memory.cpp @@ -53,42 +53,12 @@ #include #include -#include #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 -#include - -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( - dlsym(lib, "AHardwareBuffer_getNativeHandle")); -} - -} -#endif #if defined(__ANDROID__) && __ANDROID_API__ < 30 #include @@ -152,7 +122,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_, size_t) + explicit Impl(size_t backing_size_, size_t virtual_size_) : backing_size{backing_size_} , virtual_size{virtual_size_} , process{GetCurrentProcess()} @@ -530,10 +500,9 @@ static int shm_open_anon(int flags, mode_t mode) { class HostMemory::Impl { public: - explicit Impl(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_) + explicit Impl(size_t backing_size_, size_t virtual_size_) : backing_size{backing_size_} , virtual_size{virtual_size_} - , preferred_offset{preferred_offset_} {} bool Init() { @@ -573,15 +542,10 @@ public: LOG_WARNING(Common_Memory, "Using private mappings instead of shared ones"); backing_base = static_cast(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(mmap(nullptr, backing_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0)); } if (backing_base == MAP_FAILED) { @@ -589,10 +553,7 @@ public: return false; } - return InitVirtual(); - } - - bool InitVirtual() { + // Virtual memory initialization virtual_base = virtual_map_base = static_cast(ChooseVirtualBase(virtual_size)); if (virtual_base == MAP_FAILED) { LOG_CRITICAL(HW_Memory, "mmap failed: {}", strerror(errno)); @@ -605,240 +566,6 @@ public: return true; } -#ifdef __ANDROID__ - static AHardwareBuffer_Desc MakeBlobDesc(size_t len) { - return AHardwareBuffer_Desc{ - .width = static_cast(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) { - 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); - try_map(PROT_READ | PROT_WRITE, static_cast(PageAlignment)); -#ifdef ARCHITECTURE_arm64 - try_map(PROT_READ | PROT_EXEC, 0); -#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 permissible_maps = Common::GetPermissibleMapCount(); - if (permissible_maps == 0) { - return 0; - } - u64 budget = (total_physical - BaselineFootprint) / 2; - constexpr u64 MapSlotsPerWindow = 64; - const u64 affordable_windows = permissible_maps / 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(backing_size)); - budget = Common::AlignDown(budget, window_size); - constexpr u64 MinimumBudget = 256ULL << 20; - if (budget < MinimumBudget) { - return 0; - } - return static_cast(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 buffers; - std::vector 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(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(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(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; - 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(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(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 AhbWindows() const noexcept { - return ahb_windows; - } - - size_t AhbWindowSize() const noexcept { - return ahb_window_size; - } - - size_t AhbBase() const noexcept { - return ahb_base; - } -#endif - ~Impl() { Release(); } @@ -859,12 +586,6 @@ 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); @@ -912,7 +633,6 @@ public: 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(MAP_FAILED)}; u8* virtual_base{reinterpret_cast(MAP_FAILED)}; @@ -935,15 +655,6 @@ 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(); - ahb_bytes = 0; -#endif } void AdjustMap(size_t* virtual_offset, size_t* length) { @@ -969,19 +680,11 @@ private: int fd{-1}; // memfd file descriptor, -1 is the error value of memfd_create FreeRegionManager free_manager{}; - -#ifdef __ANDROID__ - std::vector ahb_windows; - std::vector 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_, size_t preferred_offset_) +HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_) : backing_size(backing_size_) , virtual_size(virtual_size_) { @@ -993,9 +696,7 @@ HostMemory::HostMemory(size_t backing_size_, size_t virtual_size_, size_t prefer #else // Try to allocate a fastmem arena. // The implementation will fail with std::bad_alloc on errors. - impl = std::make_unique(AlignUp(backing_size, PageAlignment), - AlignUp(virtual_size, PageAlignment) + HugePageSize, - preferred_offset_); + impl = std::make_unique(AlignUp(backing_size, PageAlignment), AlignUp(virtual_size, PageAlignment) + HugePageSize); if (impl->Init()) { backing_base = impl->backing_base; virtual_base = impl->virtual_base; @@ -1065,42 +766,6 @@ void HostMemory::ClearBackingRegion(size_t physical_offset, size_t length, u32 f std::memset(backing_base + physical_offset, fill_value, length); } -std::span HostMemory::BackingHardwareBuffers() const noexcept { -#ifdef __ANDROID__ - if (impl) { - return impl->AhbWindows(); - } -#endif - return {}; -} - -size_t HostMemory::BackingMapCount(size_t host_offset, size_t length) const noexcept { -#ifdef __ANDROID__ - if (impl) { - return impl->BackingMapCount(host_offset, length); - } -#endif - return static_cast(length != 0); -} - -size_t HostMemory::BackingHardwareBufferWindowSize() const noexcept { -#ifdef __ANDROID__ - if (impl) { - return impl->AhbWindowSize(); - } -#endif - return 0; -} - -size_t HostMemory::BackingHardwareBufferBase() const noexcept { -#ifdef __ANDROID__ - if (impl) { - return impl->AhbBase(); - } -#endif - return 0; -} - void HostMemory::EnableDirectMappedAddress() { #if !(defined(__OPENORBIS__) || defined(__managarm__)) if (impl) { diff --git a/src/common/host_memory.h b/src/common/host_memory.h index 3299680580..24f4670732 100644 --- a/src/common/host_memory.h +++ b/src/common/host_memory.h @@ -8,13 +8,10 @@ #include #include -#include #include "common/common_funcs.h" #include "common/common_types.h" #include "common/virtual_buffer.h" -struct AHardwareBuffer; - namespace Common { enum class MemoryPermission : u32 { @@ -31,7 +28,7 @@ DECLARE_ENUM_FLAG_OPERATORS(MemoryPermission) */ class HostMemory { public: - explicit HostMemory(size_t backing_size_, size_t virtual_size_, size_t preferred_offset_ = 0); + explicit HostMemory(size_t backing_size_, size_t virtual_size_); ~HostMemory(); /** @@ -65,18 +62,6 @@ 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 BackingHardwareBuffers() const noexcept; - - [[nodiscard]] size_t BackingHardwareBufferWindowSize() const noexcept; - - [[nodiscard]] size_t BackingHardwareBufferBase() const noexcept; - [[nodiscard]] u8* VirtualBasePointer() noexcept { return virtual_base; } diff --git a/src/common/memory_detect.cpp b/src/common/memory_detect.cpp index ae303a4f1a..86a3abcc6d 100644 --- a/src/common/memory_detect.cpp +++ b/src/common/memory_detect.cpp @@ -1,6 +1,3 @@ -// 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 @@ -20,10 +17,6 @@ #endif #endif -#include -#include -#include - #include "common/memory_detect.h" namespace Common { @@ -76,61 +69,4 @@ const MemoryInfo& GetMemInfo() { return mem_info; } -u64 GetPermissibleMapCount() { - constexpr u64 DefaultMapCount = 65530; - constexpr u64 ReservedMaps = 20000; - u64 count = DefaultMapCount; -#ifdef __linux__ - if (std::FILE* const file = std::fopen("/proc/sys/vm/max_map_count", "re")) { - char line[32]; - if (std::fgets(line, sizeof(line), file) != nullptr) { - const u64 parsed = std::strtoull(line, nullptr, 10); - if (parsed != 0) { - count = parsed; - } - } - std::fclose(file); - } -#endif - if (count <= ReservedMaps) { - return 0; - } - return count - ReservedMaps; -} - -u64 GetAvailablePhysicalMemory() { -#ifdef _WIN32 - MEMORYSTATUSEX memorystatus; - memorystatus.dwLength = sizeof(memorystatus); - if (GlobalMemoryStatusEx(&memorystatus) == 0) { - return 0; - } - return memorystatus.ullAvailPhys; -#elif defined(__linux__) - static constexpr char AvailableKey[] = "MemAvailable:"; - 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, AvailableKey, sizeof(AvailableKey) - 1) != 0) { - continue; - } - available = std::strtoull(line + sizeof(AvailableKey) - 1, nullptr, 10) * 1024; - break; - } - std::fclose(file); - if (available != 0) { - return available; - } - } - struct sysinfo meminfo; - if (sysinfo(&meminfo) != 0) { - return 0; - } - return static_cast(meminfo.freeram) * static_cast(meminfo.mem_unit); -#else - return 0; -#endif -} - } // namespace Common diff --git a/src/common/memory_detect.h b/src/common/memory_detect.h index 367e3f754d..c8f239aed3 100644 --- a/src/common/memory_detect.h +++ b/src/common/memory_detect.h @@ -1,6 +1,3 @@ -// 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 @@ -21,8 +18,4 @@ struct MemoryInfo { */ [[nodiscard]] const MemoryInfo& GetMemInfo(); -[[nodiscard]] u64 GetPermissibleMapCount(); - -[[nodiscard]] u64 GetAvailablePhysicalMemory(); - } // namespace Common diff --git a/src/core/core.cpp b/src/core/core.cpp index 10d1c336c4..046ee53346 100644 --- a/src/core/core.cpp +++ b/src/core/core.cpp @@ -120,7 +120,6 @@ 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(); }); @@ -148,8 +147,7 @@ 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) || - unified_memory != Settings::values.use_unified_memory.GetValue(); + Settings::MemoryLayout::Memory_4Gb); if (!must_reinitialize) { return; @@ -537,7 +535,6 @@ 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; diff --git a/src/core/device_memory.cpp b/src/core/device_memory.cpp index 8d56f86be9..1aea56a991 100644 --- a/src/core/device_memory.cpp +++ b/src/core/device_memory.cpp @@ -1,6 +1,3 @@ -// 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 @@ -15,21 +12,9 @@ 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(); - if (dram_size <= application_pool_size) { - return 0; - } - return dram_size - application_pool_size; -} -} - DeviceMemory::DeviceMemory() : buffer{Kernel::Board::Nintendo::Nx::KSystemControl::Init::GetIntendedMemorySize(), - VirtualReserveSize, ApplicationPoolOffset()} {} + VirtualReserveSize} {} DeviceMemory::~DeviceMemory() = default; diff --git a/src/video_core/renderer_vulkan/vk_guest_memory.cpp b/src/video_core/renderer_vulkan/vk_guest_memory.cpp index 7d0d28852d..9b2fd20694 100644 --- a/src/video_core/renderer_vulkan/vk_guest_memory.cpp +++ b/src/video_core/renderer_vulkan/vk_guest_memory.cpp @@ -3,14 +3,10 @@ #include #include -#include #include -#include -#include "common/host_memory.h" #include "video_core/renderer_vulkan/vk_guest_memory.h" #include "video_core/renderer_vulkan/vk_scheduler.h" -#include "video_core/vulkan_common/vulkan_device.h" #include "video_core/vulkan_common/vulkan_memory_allocator.h" namespace Vulkan { @@ -21,9 +17,9 @@ constexpr u32 PROBE_CPU_STRIDE = 0x9E3779B9U; constexpr u32 PROBE_GPU_VALUE = 0x5AC3E10FU; } -GuestMemory::GuestMemory(const Device& device, MemoryAllocator& memory_allocator, - Scheduler& scheduler, const Common::HostMemory& host_memory) { - Import(device, host_memory); +GuestMemory::GuestMemory([[maybe_unused]] const Device& device, + MemoryAllocator& memory_allocator, Scheduler& scheduler, + [[maybe_unused]] const Common::HostMemory& host_memory) { if (!windows.empty() && !IsCoherent(memory_allocator, scheduler)) { windows.clear(); } @@ -42,71 +38,6 @@ std::optional GuestMemory::Find(const u8* pointer, size_t si return Range{*windows[index].buffer, local_offset}; } -void GuestMemory::Import([[maybe_unused]] const Device& device, - [[maybe_unused]] const Common::HostMemory& host_memory) { -#ifdef __ANDROID__ - const std::span hardware_buffers = - host_memory.BackingHardwareBuffers(); - window_size = host_memory.BackingHardwareBufferWindowSize(); - if (hardware_buffers.empty() || window_size == 0 || !device.IsAhbImportSupported()) { - return; - } - base = const_cast(host_memory.BackingBasePointer()) + - host_memory.BackingHardwareBufferBase(); - const vk::Device& logical = device.GetLogical(); - try { - for (AHardwareBuffer* const hardware_buffer : hardware_buffers) { - const VkAndroidHardwareBufferPropertiesANDROID properties = - logical.GetAndroidHardwareBufferProperties(hardware_buffer); - 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, - }; - Window& window = windows.emplace_back(); - window.buffer = logical.CreateExternalBuffer(VkBufferCreateInfo{ - .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, - .pNext = &external_info, - .flags = 0, - .size = window_size, - .usage = VK_BUFFER_USAGE_STORAGE_BUFFER_BIT | VK_BUFFER_USAGE_TRANSFER_SRC_BIT | - VK_BUFFER_USAGE_TRANSFER_DST_BIT, - .sharingMode = VK_SHARING_MODE_EXCLUSIVE, - .queueFamilyIndexCount = 0, - .pQueueFamilyIndices = nullptr, - }); - const u32 type_bits = - logical.GetBufferMemoryRequirements(*window.buffer).memoryTypeBits & - properties.memoryTypeBits; - if (type_bits == 0) { - windows.clear(); - return; - } - const VkImportAndroidHardwareBufferInfoANDROID import_info{ - .sType = VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID, - .pNext = nullptr, - .buffer = hardware_buffer, - }; - const VkMemoryDedicatedAllocateInfo dedicated_info{ - .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, - .pNext = &import_info, - .image = VK_NULL_HANDLE, - .buffer = *window.buffer, - }; - window.memory = logical.AllocateMemory(VkMemoryAllocateInfo{ - .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, - .pNext = &dedicated_info, - .allocationSize = properties.allocationSize, - .memoryTypeIndex = static_cast(std::countr_zero(type_bits)), - }); - logical.BindBufferMemory(*window.buffer, *window.memory, 0); - } - } catch (const vk::Exception&) { - windows.clear(); - } -#endif -} - bool GuestMemory::IsCoherent(MemoryAllocator& memory_allocator, Scheduler& scheduler) const { const VkDeviceSize probe_offset = window_size - PROBE_SIZE; u8* const probe = base + (windows.size() - 1) * window_size + probe_offset; diff --git a/src/video_core/renderer_vulkan/vk_guest_memory.h b/src/video_core/renderer_vulkan/vk_guest_memory.h index 10128392e4..ae206109ad 100644 --- a/src/video_core/renderer_vulkan/vk_guest_memory.h +++ b/src/video_core/renderer_vulkan/vk_guest_memory.h @@ -41,8 +41,6 @@ private: vk::ExternalBuffer buffer; }; - void Import(const Device& device, const Common::HostMemory& host_memory); - [[nodiscard]] bool IsCoherent(MemoryAllocator& memory_allocator, Scheduler& scheduler) const; std::vector windows; diff --git a/src/video_core/vulkan_common/vulkan_device.cpp b/src/video_core/vulkan_common/vulkan_device.cpp index 12d7cfbba8..cd5e5a8412 100644 --- a/src/video_core/vulkan_common/vulkan_device.cpp +++ b/src/video_core/vulkan_common/vulkan_device.cpp @@ -934,15 +934,6 @@ bool Device::GetSuitability(bool requires_swapchain) { FOR_EACH_VK_FEATURE_EXT(FEATURE_EXTENSION); FOR_EACH_VK_EXTENSION(EXTENSION); -#ifdef __ANDROID__ - if (supported_extensions.contains( - VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME) && - supported_extensions.contains(VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME)) { - loaded_extensions.insert(VK_ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_EXTENSION_NAME); - loaded_extensions.insert(VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME); - has_ahb_import = true; - } -#endif extensions.depth_stencil_resolve = extensions.depth_stencil_resolve && diff --git a/src/video_core/vulkan_common/vulkan_device.h b/src/video_core/vulkan_common/vulkan_device.h index ab96421c3a..63a2e5b7fa 100644 --- a/src/video_core/vulkan_common/vulkan_device.h +++ b/src/video_core/vulkan_common/vulkan_device.h @@ -993,10 +993,6 @@ FN_MAX_LIMIT_LIST return extensions.host_image_copy; } - bool IsAhbImportSupported() const { - return has_ahb_import; - } - bool HasNullDescriptor() const { return features.robustness2.nullDescriptor; } @@ -1212,7 +1208,6 @@ private: bool is_warp_potentially_bigger{}; ///< Host warp size can be bigger than guest. bool is_integrated{}; ///< Is GPU an iGPU. bool is_uma{}; - bool has_ahb_import{}; bool has_broken_compute{}; ///< Compute shaders can cause crashes bool has_broken_cube_compatibility{}; ///< Has broken cube compatibility bit bool has_broken_float16_math{}; diff --git a/src/video_core/vulkan_common/vulkan_wrapper.cpp b/src/video_core/vulkan_common/vulkan_wrapper.cpp index 1d728e9113..c6b3afa2c7 100644 --- a/src/video_core/vulkan_common/vulkan_wrapper.cpp +++ b/src/video_core/vulkan_common/vulkan_wrapper.cpp @@ -88,9 +88,6 @@ void Load(VkDevice device, DeviceDispatch& dld) noexcept { X(vkAllocateMemory); X(vkBindBufferMemory); X(vkFreeMemory); -#ifdef __ANDROID__ - X(vkGetAndroidHardwareBufferPropertiesANDROID); -#endif X(vkBeginCommandBuffer); X(vkCmdBeginConditionalRenderingEXT); X(vkCmdBeginQuery); @@ -657,20 +654,6 @@ VkMemoryRequirements Device::GetBufferMemoryRequirements(VkBuffer buffer) const return requirements.memoryRequirements; } -#ifdef __ANDROID__ -VkAndroidHardwareBufferPropertiesANDROID Device::GetAndroidHardwareBufferProperties( - const AHardwareBuffer* buffer) const { - VkAndroidHardwareBufferPropertiesANDROID properties{ - .sType = VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID, - .pNext = nullptr, - .allocationSize = 0, - .memoryTypeBits = 0, - }; - Check(dld->vkGetAndroidHardwareBufferPropertiesANDROID(handle, buffer, &properties)); - return properties; -} -#endif - ImageView Device::CreateImageView(const VkImageViewCreateInfo& ci) const { VkImageView object; Check(dld->vkCreateImageView(handle, &ci, nullptr, &object)); diff --git a/src/video_core/vulkan_common/vulkan_wrapper.h b/src/video_core/vulkan_common/vulkan_wrapper.h index e0bb7585ac..bd9bd1b5bd 100644 --- a/src/video_core/vulkan_common/vulkan_wrapper.h +++ b/src/video_core/vulkan_common/vulkan_wrapper.h @@ -237,9 +237,6 @@ struct DeviceDispatch : InstanceDispatch { PFN_vkAllocateMemory vkAllocateMemory{}; PFN_vkBindBufferMemory vkBindBufferMemory{}; PFN_vkFreeMemory vkFreeMemory{}; -#ifdef __ANDROID__ - PFN_vkGetAndroidHardwareBufferPropertiesANDROID vkGetAndroidHardwareBufferPropertiesANDROID{}; -#endif PFN_vkBeginCommandBuffer vkBeginCommandBuffer{}; PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT{}; PFN_vkCmdBeginQuery vkCmdBeginQuery{}; @@ -1017,11 +1014,6 @@ public: [[nodiscard]] VkMemoryRequirements GetBufferMemoryRequirements(VkBuffer buffer) const noexcept; -#ifdef __ANDROID__ - [[nodiscard]] VkAndroidHardwareBufferPropertiesANDROID GetAndroidHardwareBufferProperties( - const AHardwareBuffer* buffer) const; -#endif - [[nodiscard]] ImageView CreateImageView(const VkImageViewCreateInfo& ci) const; [[nodiscard]] Semaphore CreateSemaphore() const;