Mempressure: fix mempressure detection on linux, add memory pressure detection for macOS

- Linux: Use /proc/meminfo MemAvailable (accounts for reclaimable memory),
  with /proc/self/meminfo preferred for container environments
- Windows: Use GlobalMemoryStatusEx with Job Object support for container
  memory limit detection
- macOS: Use kern.memorystatus_vm_pressure_level sysctl to detect kernel
  memory pressure levels

Split SystemNeedsMemoryReleased into two functions:
- CheckMemoryPressure(): updates atomic flag
- SystemNeedsMemoryReleased(): read of cached flag

Schedule CheckMemoryPressure to run every 10 seconds, and recheck after
FlushStateToDisk to prevent repeated flushes on the same pressure event.

Author: bigshiny90

src/init.cpp

@@ -1605,6 +1605,12 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         }
     }, std::chrono::minutes{5});
 
+    // Check system memory pressure every 10 seconds.
+    // Updates g_system_needs_memory_released flag used by FlushStateToDisk.
+    scheduler.scheduleEvery([]{
+        CheckMemoryPressure();
+    }, std::chrono::seconds{10});
+
     if (args.GetBoolArg("-logratelimit", BCLog::DEFAULT_LOGRATELIMIT)) {
         LogInstance().SetRateLimiting(BCLog::LogRateLimiter::Create(
             [&scheduler](auto func, auto window) { scheduler.scheduleEvery(std::move(func), window); },

src/util/CMakeLists.txt

@@ -46,4 +46,5 @@ target_link_libraries(bitcoin_util
     bitcoin_crypto
     $<$<PLATFORM_ID:Windows>:ws2_32>
     $<$<PLATFORM_ID:Windows>:iphlpapi>
+    $<$<PLATFORM_ID:Windows>:psapi>
 )

src/util/mempressure.cpp

@@ -9,48 +9,168 @@
 #include <logging.h>
 #include <util/byte_units.h>
 
-#ifdef HAVE_LINUX_SYSINFO
-#include <sys/sysinfo.h>
-#endif
 #ifdef WIN32
 #include <windows.h>
+#include <psapi.h>
+#endif
+
+#ifdef __APPLE__
+#include <sys/sysctl.h>
 #endif
 
+#include <algorithm>
+#include <atomic>
 #include <cstddef>
 #include <cstdint>
+#include <exception>
+#include <fstream>
+#include <string>
 
 size_t g_low_memory_threshold{64_MiB};
+std::atomic<bool> g_system_needs_memory_released{false};
 
-bool SystemNeedsMemoryReleased()
+#ifdef WIN32
+namespace {
+    // Query Job Object memory limit for Windows container support.
+    // Docker, etc on Windows use Job Objects to enforce memory limits.
+    size_t GetJobObjectMemoryLimit()
+    {
+        // Query information about the job object the current process belongs to
+        JOBOBJECT_EXTENDED_LIMIT_INFORMATION job_info = {};
+
+        if (QueryInformationJobObject(nullptr, JobObjectExtendedLimitInformation,
+                                       &job_info, sizeof(job_info), nullptr)) {
+            // Check if job memory limit is set
+            if (job_info.BasicLimitInformation.LimitFlags & JOB_OBJECT_LIMIT_JOB_MEMORY) {
+                SIZE_T job_memory_limit = job_info.JobMemoryLimit;
+
+                // JobMemoryLimit can be in bytes or pages depending on flags
+                // For modern Windows containers, it's typically in bytes
+                if (job_memory_limit > 0 && job_memory_limit < SIZE_MAX) {
+                    LogPrintf("GetJobObjectMemoryLimit: Detected Job Object memory limit: %zu bytes\n",
+                              job_memory_limit);
+                    return static_cast<size_t>(job_memory_limit);
+                }
+            }
+        }
+
+        // Not in a job object with memory limits (bare metal Windows)
+        return 0;
+    }
+
+}
+#endif
+
+void CheckMemoryPressure()
 {
     if (g_low_memory_threshold <= 0) {
         // Intentionally bypass other metrics when disabled entirely
-        return false;
+        g_system_needs_memory_released.store(false, std::memory_order_relaxed);
+        return;
     }
+
+    bool needs_release = false;
+
 #ifdef WIN32
     MEMORYSTATUSEX mem_status;
     mem_status.dwLength = sizeof(mem_status);
     if (GlobalMemoryStatusEx(&mem_status)) {
-        if (mem_status.dwMemoryLoad >= 99 ||
-            mem_status.ullAvailPhys < g_low_memory_threshold ||
-            mem_status.ullAvailVirtual < g_low_memory_threshold) {
-            LogPrintf("%s: YES: %s%% memory load; %s available physical memory; %s available virtual memory\n", __func__, int(mem_status.dwMemoryLoad), size_t(mem_status.ullAvailPhys), size_t(mem_status.ullAvailVirtual));
-            return true;
+        // Use the lesser of available physical or virtual memory
+        size_t available_memory = std::min(static_cast<size_t>(mem_status.ullAvailPhys),
+                                           static_cast<size_t>(mem_status.ullAvailVirtual));
+
+        // Check if running in a Windows container with memory limits
+        size_t container_memory_limit = GetJobObjectMemoryLimit();
+        if (container_memory_limit > 0) {
+            // In a container - try to get container-aware available memory
+            PROCESS_MEMORY_COUNTERS_EX pmc;
+            if (GetProcessMemoryInfo(GetCurrentProcess(), (PROCESS_MEMORY_COUNTERS*)&pmc, sizeof(pmc))) {
+                // Success - use container available memory calculation
+                size_t current_usage = pmc.PrivateUsage;
+                available_memory = (current_usage < container_memory_limit)
+                                   ? (container_memory_limit - current_usage)
+                                   : 0;
+            }
+            // If GetProcessMemoryInfo failed, keep using system available_memory as fallback
+        }
+
+        if (mem_status.dwMemoryLoad >= 99 || available_memory < g_low_memory_threshold) {
+            LogPrintf("%s: YES: %d%% memory load; %zu available memory%s\n",
+                      __func__, int(mem_status.dwMemoryLoad), available_memory,
+                      container_memory_limit > 0 ? " (in container)" : "");
+            needs_release = true;
+        }
+    }
+#endif
+#ifdef __linux__
+    // use /proc/meminfo MemAvailable
+    // - Prefer /proc/self/meminfo for containerized environments
+    // - Fallback to /proc/meminfo otherwise
+    // - /proc/self/meminfo should return same info if available and not in a container
+    std::ifstream meminfo("/proc/self/meminfo");
+    if (!meminfo.is_open()) {
+        meminfo.open("/proc/meminfo");
+    }
+
+    if (meminfo.is_open()) {
+        std::string line;
+        while (std::getline(meminfo, line)) {
+            if (line.compare(0, 13, "MemAvailable:") == 0) {
+                // Format: "MemAvailable:    1234567 kB"
+                size_t pos = line.find_first_of("0123456789");
+                if (pos != std::string::npos) {
+                    try {
+                        uint64_t mem_kb = std::stoull(line.substr(pos));
+
+                        // Check for overflow before multiplication
+                        if (mem_kb > UINT64_MAX / 1024) {
+                            // huge value is "plenty of memory"
+                            break;
+                        }
+
+                        uint64_t available_memory = mem_kb * 1024;
+
+                        if (available_memory < g_low_memory_threshold) {
+                            LogPrintf("%s: YES: %s available memory\n", __func__, available_memory);
+                            needs_release = true;
+                        }
+                    } catch (const std::exception& e) {
+                        // Invalid format in /proc/meminfo - ignore and leave needs_release as false
+                        LogPrintf("%s: Failed to parse MemAvailable: %s\n", __func__, e.what());
+                    }
+                }
+                break;
+            }
         }
     }
 #endif
-#ifdef HAVE_LINUX_SYSINFO
-    struct sysinfo sys_info;
-    if (!sysinfo(&sys_info)) {
-        // Explicitly 64-bit in case of 32-bit userspace on 64-bit kernel
-        const uint64_t free_ram = uint64_t(sys_info.freeram) * sys_info.mem_unit;
-        const uint64_t buffer_ram = uint64_t(sys_info.bufferram) * sys_info.mem_unit;
-        if (free_ram + buffer_ram < g_low_memory_threshold) {
-            LogPrintf("%s: YES: %s free RAM + %s buffer RAM\n", __func__, free_ram, buffer_ram);
-            return true;
+#ifdef __APPLE__
+    // On macOS, use kern.memorystatus_vm_pressure_level sysctl.
+    // TODO: native macOS containers may need more complex handling.
+    // - NORMAL (1): No pressure
+    // - WARN (2): Kernel has begun mitigations (compression) - trigger reclamation
+    // - CRITICAL (4): System actively paging to disk - aggressive reclamation needed
+    int pressure_level = 0;
+    size_t size = sizeof(pressure_level);
+
+    if (sysctlbyname("kern.memorystatus_vm_pressure_level", &pressure_level, &size, nullptr, 0) == 0) {
+        // Trigger memory release at WARN level or higher
+        if (pressure_level >= 2) {
+            LogPrintf("%s: YES: macOS memory pressure level %d (WARN or CRITICAL)\n", __func__, pressure_level);
+            needs_release = true;
         }
     }
 #endif
-    // NOTE: sysconf(_SC_AVPHYS_PAGES) doesn't account for caches on at least Linux, so not safe to use here
-    return false;
+
+    g_system_needs_memory_released.store(needs_release, std::memory_order_relaxed);
+}
+
+bool SystemNeedsMemoryReleased()
+{
+    if (g_low_memory_threshold <= 0) {
+        // Intentionally bypass if disabled (lowmem=0)
+        return false;
+    }
+
+    return g_system_needs_memory_released.load(std::memory_order_relaxed);
 }

src/util/mempressure.h

@@ -5,10 +5,24 @@
 #ifndef BITCOIN_UTIL_MEMPRESSURE_H
 #define BITCOIN_UTIL_MEMPRESSURE_H
 
+#include <atomic>
 #include <cstddef>
+#include <cstdint>
 
 extern size_t g_low_memory_threshold;
+extern std::atomic<bool> g_system_needs_memory_released;
 
+/** Checks system memory pressure and updates g_system_needs_memory_released flag.
+ * On Linux, reads /proc/meminfo MemAvailable or /proc/self/meminfo if in a cgroup (container).
+ * On Windows, uses GlobalMemoryStatusEx and/or Job Object limits if in a container.
+ * On macOS, uses kern.memorystatus_vm_pressure_level sysctl.
+ * This function is called periodically by the scheduler, and also after memory release.
+ */
+void CheckMemoryPressure();
+
+/** Fast check if system needs memory released.
+ * Returns the cached g_system_needs_memory_released flag.
+ */
 bool SystemNeedsMemoryReleased();
 
 #endif // BITCOIN_UTIL_MEMPRESSURE_H

src/validation.cpp

@@ -3215,6 +3215,12 @@ bool Chainstate::FlushStateToDisk(
                    (uint64_t)coins_mem_usage,
                    (bool)fFlushForPrune);
 
+            // After flushing, immediately recheck memory pressure to update the flag
+            // This prevents repeated flushes on the same memory pressure event
+            if (SystemNeedsMemoryReleased()) {
+                CheckMemoryPressure();
+            }
+
             }
         }