[mpt] Scale slow-list compaction by gc_efficiency relative to disk growth

Replace the fixed cap (min of growth+1 and gc_efficiency) with a
formula that scales growth by gc_efficiency / breakeven. Above the
breakeven (4), compaction outruns growth to reduce backlog; below it,
compaction backs off when recirculation is heavy.

Author: Chen-Yifan

category/mpt/update_aux.cpp

@@ -1490,22 +1490,25 @@ void UpdateAuxImpl::advance_compact_offsets(Node::SharedPtr const prev_root)
     // <-- Slow list compaction -->
     constexpr double usage_limit_start_compact_slow = 0.6;
     constexpr double slow_usage_limit_start_compact_slow = 0.2;
+    constexpr uint32_t gc_efficiency_breakeven = 4;
+
     double const slow_disk_usage =
         num_chunks(chunk_list::slow) / (double)io->chunk_count();
     // Do not compact slow list until slow list usage and total usage are both
     // above the thresholds
     if (disk_usage() > usage_limit_start_compact_slow &&
         slow_disk_usage > slow_usage_limit_start_compact_slow) {
-        // Compact slow ring: the offset is based on slow list garbage
-        // collection ratio of the last block. We use the ratio of compacted
-        // bytes to determine how aggressively to advance the compaction head.
+        // Compact slow ring at growth rate scaled by gc_efficiency.
+        // The breakeven point is 4, above which we compact faster than
+        // growth (reduce backlog), below 4 we compact slower (back off
+        // when recirculation is heavy).
         uint32_t to_advance =
-            1; // No active data in last compaction, use minimum progress
+            3; // No active data in last compaction, use minimum progress
         if (last_block_slow_list_gc_efficiency_ > 0) {
-            // Cap at last block's growth + 1 to avoid advancing too fast
-            to_advance = std::min(
-                static_cast<uint32_t>(last_block_disk_growth_slow_ + 1),
-                last_block_slow_list_gc_efficiency_);
+            to_advance = static_cast<uint32_t>(
+                static_cast<uint64_t>(last_block_disk_growth_slow_) *
+                last_block_slow_list_gc_efficiency_ / gc_efficiency_breakeven);
+            to_advance = std::min(to_advance, max_compact_offset_range);
         }
         compact_offset_range_slow_.set_value(to_advance);
         compact_offsets.slow += compact_offset_range_slow_;