world loading memory pressure detector

Signed-off-by: Pavel Okhlopkov <pavel.okhlopkov@flant.com>

include/core/memory_monitor.hpp

@@ -34,10 +34,17 @@ public:
     size_t getRecommendedCacheBudget() const;
 
     /**
-     * Check if system is under memory pressure
+     * Check if system is under memory pressure (< 10% RAM available)
      */
     bool isMemoryPressure() const;
 
+    /**
+     * Check if system is under severe memory pressure (< 15% RAM available).
+     * At this level, background loading should pause entirely until memory
+     * is freed — continuing to allocate risks OOM-killing other applications.
+     */
+    bool isSevereMemoryPressure() const;
+
 private:
     MemoryMonitor() = default;
     size_t totalRAM_ = 0;

include/rendering/terrain_manager.hpp

@@ -366,6 +366,11 @@ private:
     std::condition_variable queueCV;
     std::deque<TileCoord> loadQueue;
     std::queue<std::shared_ptr<PendingTile>> readyQueue;
+    // Maximum number of prepared-but-not-finalized tiles in readyQueue.
+    // Each prepared tile can hold 100–500 MB of decoded textures in RAM.
+    // Workers sleep when this limit is reached, letting the main thread
+    // finalize (GPU-upload + free) before more tiles are prepared.
+    static constexpr size_t maxReadyQueueSize_ = 3;
 
     // In-RAM tile cache (LRU) to avoid re-reading from disk
     struct CachedTile {

src/core/memory_monitor.cpp

@@ -126,5 +126,12 @@ bool MemoryMonitor::isMemoryPressure() const {
     return available < (totalRAM_ * 10 / 100);
 }
 
+bool MemoryMonitor::isSevereMemoryPressure() const {
+    size_t available = getAvailableRAM();
+    // Severe pressure if < 15% RAM available — background workers should
+    // pause entirely to avoid OOM-killing other applications.
+    return available < (totalRAM_ * 15 / 100);
+}
+
 } // namespace core
 } // namespace wowee

src/rendering/terrain_manager.cpp

@@ -1212,6 +1212,28 @@ void TerrainManager::workerLoop() {
                 break;
             }
 
+            // --- Memory-aware throttling ---
+            // Back-pressure: if the ready queue is deep (finalization can't
+            // keep up), or the system is running low on RAM, sleep instead
+            // of pulling more tiles.  Each prepared tile can hold hundreds
+            // of MB of decoded textures; limiting concurrency here prevents
+            // WoWee from consuming all system memory during world load.
+            const auto& memMon = core::MemoryMonitor::getInstance();
+            if (memMon.isSevereMemoryPressure()) {
+                // Severe pressure — don't pull ANY work until main thread
+                // finalizes tiles and frees decoded texture data.
+                lock.unlock();
+                std::this_thread::sleep_for(std::chrono::milliseconds(200));
+                continue;
+            }
+            if (readyQueue.size() >= maxReadyQueueSize_ || memMon.isMemoryPressure()) {
+                // Moderate pressure or ready queue is backing up — sleep briefly
+                // to let the main thread catch up with finalization.
+                lock.unlock();
+                std::this_thread::sleep_for(std::chrono::milliseconds(50));
+                continue;
+            }
+
             if (!loadQueue.empty()) {
                 coord = loadQueue.front();
                 loadQueue.pop_front();