mempressure: Implement two-stage memory release for memory pressure events

Implements Luke's two-stage approach for responding to memory pressure:
- Stage 1: Drop clean cache entries
- Stage 2: If still under pressure, Sync() dirty entries then drop those

Changes:
- Add CCoinsViewCache::UncacheCleanEntries() to remove all clean entries
- Add CCoinsViewCache::HandleMemoryPressure() encapsulating two-stage logic
- Track memory pressure separately from cache size limits in FlushStateToDisk
- Apply two-stage approach only to system memory pressure events

Additional improvements:
- Simplified scheduler to fixed 10-second interval (avoid self-referential lambda)
- Added exception handling for std::stoull when parsing /proc/meminfo

Addresses #216

Author: bigshiny90

src/coins.cpp

@@ -7,6 +7,7 @@
 #include <consensus/consensus.h>
 #include <logging.h>
 #include <random.h>
+#include <util/mempressure.h>
 #include <util/trace.h>
 
 TRACEPOINT_SEMAPHORE(utxocache, add);
@@ -286,6 +287,48 @@ void CCoinsViewCache::Uncache(const COutPoint& hash)
     }
 }
 
+size_t CCoinsViewCache::UncacheCleanEntries()
+{
+    size_t freed = 0;
+    for (auto it = cacheCoins.begin(); it != cacheCoins.end(); ) {
+        // Only remove clean entries (not dirty, not fresh)
+        if (!it->second.IsDirty() && !it->second.IsFresh()) {
+            size_t coin_usage = it->second.coin.DynamicMemoryUsage();
+            freed += coin_usage;
+            cachedCoinsUsage -= coin_usage;
+            it = cacheCoins.erase(it);
+        } else {
+            ++it;
+        }
+    }
+    return freed;
+}
+
+bool CCoinsViewCache::HandleMemoryPressure()
+{
+    // Stage 1: Drop clean entries (fast, no disk I/O)
+    size_t freed = UncacheCleanEntries();
+    LogPrintLevel(BCLog::COINDB, BCLog::Level::Info, "Memory pressure: freed %d bytes from clean cache entries\n", freed);
+
+    // Recheck memory pressure after freeing clean entries
+    CheckMemoryPressure();
+
+    // Stage 2: If still under pressure, sync dirty entries and drop those
+    if (SystemNeedsMemoryReleased()) {
+        LogPrintLevel(BCLog::COINDB, BCLog::Level::Info, "Memory pressure: still critical after freeing clean entries, syncing dirty entries\n");
+        if (!Sync()) {
+            return false;
+        }
+        // Drop the newly-cleaned entries
+        size_t freed_stage2 = UncacheCleanEntries();
+        LogPrintLevel(BCLog::COINDB, BCLog::Level::Info, "Memory pressure: freed additional %d bytes after sync, total freed %d bytes\n", freed_stage2, freed + freed_stage2);
+
+        // Final recheck
+        CheckMemoryPressure();
+    }
+    return true;
+}
+
 unsigned int CCoinsViewCache::GetCacheSize() const {
     return cacheCoins.size();
 }

src/coins.h

@@ -460,6 +460,21 @@ class CCoinsViewCache : public CCoinsViewBacked
      */
     void Uncache(const COutPoint &outpoint);
 
+    /**
+     * Removes all clean (not dirty, not fresh) entries from the cache.
+     * Used during memory pressure to free memory without disk I/O.
+     * Returns the amount of memory freed in bytes.
+     */
+    size_t UncacheCleanEntries();
+
+    /**
+     * Two-stage memory pressure response.
+     * Stage 1: Drop clean entries (no disk I/O).
+     * Stage 2: If still pressure, Sync() dirty entries then drop those.
+     * Returns false if Sync() fails, true otherwise.
+     */
+    bool HandleMemoryPressure();
+
     //! Calculate the size of the cache (in number of transaction outputs)
     unsigned int GetCacheSize() const;
 

src/init.cpp

@@ -1605,28 +1605,11 @@ bool AppInitMain(NodeContext& node, interfaces::BlockAndHeaderTipInfo* tip_info)
         }
     }, std::chrono::minutes{5});
 
-    // Check system memory pressure periodically (dynamic interval based on IBD status).
-    // During IBD: check every 10 seconds for faster response to memory pressure.
-    // During normal operation: check every 10 minutes (between block arrivals).
-    // FlushStateToDisk calls SystemNeedsMemoryReleased() which uses the cached flag.
-    std::function<void()> check_memory_pressure;
-    check_memory_pressure = [&node, &scheduler, &check_memory_pressure]() {
-        // Check memory pressure and update the flag
+    // Check system memory pressure every 10 seconds.
+    // Updates g_system_needs_memory_released flag used by FlushStateToDisk.
+    scheduler.scheduleEvery([]{
         CheckMemoryPressure();
-
-        // Determine next check interval based on IBD status
-        std::chrono::milliseconds next_interval;
-        if (node.chainman && node.chainman->IsInitialBlockDownload()) {
-            next_interval = std::chrono::seconds{10};  // Fast checks during IBD
-        } else {
-            next_interval = std::chrono::minutes{10};  // Slower checks during normal operation
-        }
-
-        // Reschedule ourselves with the appropriate interval
-        scheduler.scheduleFromNow(check_memory_pressure, next_interval);
-    };
-    // Initial schedule - start with fast interval
-    scheduler.scheduleFromNow(check_memory_pressure, std::chrono::seconds{10});
+    }, std::chrono::seconds{10});
 
     if (args.GetBoolArg("-logratelimit", BCLog::DEFAULT_LOGRATELIMIT)) {
         LogInstance().SetRateLimiting(BCLog::LogRateLimiter::Create(

src/util/mempressure.cpp

@@ -16,6 +16,7 @@
 #include <atomic>
 #include <cstddef>
 #include <cstdint>
+#include <exception>
 #include <fstream>
 #include <string>
 
@@ -54,12 +55,24 @@ void CheckMemoryPressure()
                 // Format: "MemAvailable:    1234567 kB"
                 size_t pos = line.find_first_of("0123456789");
                 if (pos != std::string::npos) {
-                    uint64_t mem_kb = std::stoull(line.substr(pos));
-                    uint64_t available_memory = mem_kb * 1024; // Convert kB to bytes
+                    try {
+                        uint64_t mem_kb = std::stoull(line.substr(pos));
 
-                    if (available_memory < g_low_memory_threshold) {
-                        LogPrintf("%s: YES: %s available memory\n", __func__, available_memory);
-                        needs_release = true;
+                        // Check for overflow before multiplication
+                        if (mem_kb > UINT64_MAX / 1024) {
+                            // Treat huge values as "plenty of memory"
+                            break;
+                        }
+
+                        uint64_t available_memory = mem_kb * 1024; // Convert kB to bytes
+
+                        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 from /proc/meminfo: %s\n", __func__, e.what());
                     }
                 }
                 break;

src/validation.cpp

@@ -3144,11 +3144,14 @@ bool Chainstate::FlushStateToDisk(
         // The cache is large and we're within 10% and 10 MiB of the limit, but we have time now (not in the middle of a block processing).
         bool fCacheLarge = mode == FlushStateMode::PERIODIC && cache_state >= CoinsCacheSizeState::LARGE;
         bool fCacheCritical = false;
+        bool fMemoryPressure = false;
         if (mode == FlushStateMode::IF_NEEDED) {
             if (cache_state >= CoinsCacheSizeState::CRITICAL) {
                 // The cache is over the limit, we have to write now.
                 fCacheCritical = true;
             } else if (SystemNeedsMemoryReleased()) {
+                // System memory pressure - use two-stage approach
+                fMemoryPressure = true;
                 fCacheCritical = true;
             }
         }
@@ -3203,24 +3206,27 @@ bool Chainstate::FlushStateToDisk(
                 return FatalError(m_chainman.GetNotifications(), state, _("Disk space is too low!"));
             }
             // Flush the chainstate (which may refer to block index entries).
-            const auto empty_cache{(mode == FlushStateMode::ALWAYS) || fCacheLarge || fCacheCritical};
-            if (empty_cache ? !CoinsTip().Flush() : !CoinsTip().Sync()) {
-                return FatalError(m_chainman.GetNotifications(), state, _("Failed to write to coin database."));
+            if (fMemoryPressure) {
+                // Two-stage memory pressure response (only for system memory pressure)
+                if (!CoinsTip().HandleMemoryPressure()) {
+                    return FatalError(m_chainman.GetNotifications(), state, _("Failed to write to coin database."));
+                }
+            } else {
+                // Normal flush/sync (cache size limits, periodic writes, etc.)
+                const auto empty_cache{(mode == FlushStateMode::ALWAYS) || fCacheLarge || fCacheCritical};
+                if (empty_cache ? !CoinsTip().Flush() : !CoinsTip().Sync()) {
+                    return FatalError(m_chainman.GetNotifications(), state, _("Failed to write to coin database."));
+                }
             }
             full_flush_completed = true;
+
             TRACEPOINT(utxocache, flush,
                     int64_t{Ticks<std::chrono::microseconds>(NodeClock::now() - nNow)},
                    (uint32_t)mode,
                    (uint64_t)coins_count,
                    (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();
-            }
-
             }
         }