Keep AHB limitations

src/common/host_memory.cpp

@@ -668,11 +668,8 @@ public:
 
     size_t ComputeAhbBudget(size_t window_size) const {
         const u64 total_physical = Common::GetMemInfo().TotalPhysicalMemory;
-        if (total_physical == 0) {
-            return 0;
-        }
-        constexpr u64 MinimumTotalPhysical = 7ULL << 30;
-        if (total_physical < MinimumTotalPhysical) {
+        constexpr u64 BaselineFootprint = 6ULL << 30;
+        if (total_physical <= BaselineFootprint) {
             return 0;
         }
         const u64 max_map_count = Common::GetMaxMapCount();
@@ -680,12 +677,13 @@ public:
         if (max_map_count == 0 || max_map_count <= ReservedMaps) {
             return 0;
         }
-        u64 budget = total_physical / 6;
-        budget = (std::min)(budget, (max_map_count - ReservedMaps) * PageAlignment);
+        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) {
-            constexpr u64 Headroom = 2ULL << 30;
-            budget = (std::min)(budget, available > Headroom ? available - Headroom : 0);
+            budget = (std::min)(budget, available / 2);
         }
         budget = (std::min)(budget, static_cast<u64>(backing_size));
         budget = Common::AlignDown(budget, window_size);
@@ -705,11 +703,7 @@ public:
         if (get_native_handle == nullptr) {
             return false;
         }
-        constexpr size_t window_size = 512ULL << 20;
-        const AHardwareBuffer_Desc window_desc = MakeBlobDesc(window_size);
-        if (AHardwareBuffer_isSupported(&window_desc) == 0) {
-            return false;
-        }
+        constexpr size_t window_size = 256ULL << 20;
         const size_t budget = ComputeAhbBudget(window_size);
         if (budget == 0) {
             return false;
@@ -718,10 +712,7 @@ public:
             return false;
         }
         const size_t aligned_backing = Common::AlignDown(backing_size, window_size);
-        const size_t region_size = (std::min)(budget, aligned_backing);
-        const size_t region_base = Common::AlignDown(
-            (std::min)(preferred_offset, aligned_backing - region_size), window_size);
-        const size_t num_windows = region_size / window_size;
+        const size_t max_windows = (std::min)(budget, aligned_backing) / window_size;
 
         std::vector<AHardwareBuffer*> buffers;
         std::vector<int> buffer_fds;
@@ -732,27 +723,33 @@ public:
             buffers.clear();
             buffer_fds.clear();
         };
-        for (size_t i = 0; i < num_windows; ++i) {
+        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) {
-                cleanup();
-                return false;
+                break;
             }
-            buffers.push_back(buffer);
             const NativeHandle* const handle = get_native_handle(buffer);
             if (handle == nullptr || handle->numFds < 1) {
-                cleanup();
-                return false;
+                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)) {
-                cleanup();
-                return false;
+                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) {
@@ -820,6 +817,29 @@ public:
         }
     }
 
+    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;
     }
@@ -1077,6 +1097,14 @@ std::span<AHardwareBuffer* const> HostMemory::BackingHardwareBuffers() const noe
 #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;