[mpt] Separate fast and slow list compaction conditions in advance_compact_offsets(),

and 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

@@ -1399,7 +1399,7 @@ void UpdateAuxImpl::advance_compact_offsets(Node::SharedPtr const prev_root)
     MONAD_ASSERT(is_on_disk());
 
     constexpr double fast_usage_limit_start_compaction = 0.1;
-    constexpr unsigned fast_chunk_count_limit_start_compaction = 800;
+    constexpr size_t fast_chunk_count_limit_start_compaction = 800;
     constexpr uint32_t max_compact_offset_range =
         512; // 32MB, each unit of compact_virtual_chunk_offset_t represents
              // 64KB
@@ -1423,16 +1423,6 @@ void UpdateAuxImpl::advance_compact_offsets(Node::SharedPtr const prev_root)
         }
     }
 
-    auto const fast_disk_usage =
-        num_chunks(chunk_list::fast) / (double)io->chunk_count();
-    uint64_t const max_version = db_history_max_version();
-    if ((fast_disk_usage < fast_usage_limit_start_compaction &&
-         num_chunks(chunk_list::fast) <
-             fast_chunk_count_limit_start_compaction) ||
-        max_version == INVALID_BLOCK_NUM) {
-        return;
-    }
-
     MONAD_ASSERT(
         compact_offsets.fast != INVALID_COMPACT_VIRTUAL_OFFSET &&
         compact_offsets.slow != INVALID_COMPACT_VIRTUAL_OFFSET);
@@ -1441,74 +1431,88 @@ void UpdateAuxImpl::advance_compact_offsets(Node::SharedPtr const prev_root)
     range of the latest version, so that fast-list usage adapts appropriately to
     changes in history length. */
     compact_offset_range_fast_ = MIN_COMPACT_VIRTUAL_OFFSET;
+    compact_offset_range_slow_ = MIN_COMPACT_VIRTUAL_OFFSET;
 
-    uint64_t const min_version = db_history_min_valid_version();
-    MONAD_ASSERT(min_version != INVALID_BLOCK_NUM);
-    compact_virtual_chunk_offset_t const curr_fast_writer_offset{
-        physical_to_virtual(node_writer_fast->sender().offset())};
-    // Estimate average fast-list disk growth per version. If the oldest root
-    // is on the fast list, compute from the full history range. Otherwise fall
-    // back to the last block's growth (e.g. roots from statesync may be on the
-    // slow list).
-    uint32_t avg_disk_growth_fast = last_block_disk_growth_fast_;
-    auto const min_version_root_virtual_offset =
-        physical_to_virtual(get_root_offset_at_version(min_version));
-    if (min_version_root_virtual_offset.in_fast_list() &&
-        max_version > min_version) {
-        avg_disk_growth_fast = divide_and_round(
-            curr_fast_writer_offset -
-                compact_virtual_chunk_offset_t{min_version_root_virtual_offset},
-            max_version - min_version);
-    }
-    // Only advance the fast-list compaction offset if the uncompacted range
-    // exceeds min_versions_of_growth_before_compact_fast_list (5000) versions'
-    // worth of growth, to prevent over-compaction when the history window
-    // shrinks.
-    uint32_t const latest_block_fast_uncompacted_range =
-        curr_fast_writer_offset - compact_offsets.fast;
-    if (latest_block_fast_uncompacted_range >
-        static_cast<uint64_t>(avg_disk_growth_fast) *
-            min_versions_of_growth_before_compact_fast_list) {
-        // Stride that would evenly spread the uncompacted range across the
-        // history window, keeping fast-list disk usage steady over time.
-        uint32_t const target_fast_compaction_stride = divide_and_round(
-            latest_block_fast_uncompacted_range, max_version - min_version + 1);
-        uint32_t to_advance = std::min(
-            target_fast_compaction_stride,
-            avg_disk_growth_fast + min_compaction_progress_buffer);
-        to_advance =
-            std::min(to_advance, max_compact_offset_range); // Cap at 32MB
-        compact_offset_range_fast_.set_value(to_advance);
-        compact_offsets.fast += compact_offset_range_fast_;
+    uint64_t const max_version = db_history_max_version();
+    if (max_version == INVALID_BLOCK_NUM) {
+        return;
     }
+
+    // <-- Fast list compaction -->
+    auto const min_fast_chunks_to_start_compaction = std::min(
+        fast_chunk_count_limit_start_compaction,
+        static_cast<size_t>(
+            (double)io->chunk_count() * fast_usage_limit_start_compaction));
+    if (compact_offsets.fast < last_block_end_offset_fast_ &&
+        num_chunks(chunk_list::fast) >= min_fast_chunks_to_start_compaction) {
+        uint64_t const min_version = db_history_min_valid_version();
+        MONAD_ASSERT(min_version != INVALID_BLOCK_NUM);
+        compact_virtual_chunk_offset_t const curr_fast_writer_offset{
+            physical_to_virtual(node_writer_fast->sender().offset())};
+        // Estimate average fast-list disk growth per version. If the oldest
+        // root is on the fast list, compute from the full history range.
+        // Otherwise fall back to the last block's growth (e.g. roots from
+        // statesync may be on the slow list).
+        uint32_t avg_disk_growth_fast = last_block_disk_growth_fast_;
+        auto const min_version_root_virtual_offset =
+            physical_to_virtual(get_root_offset_at_version(min_version));
+        if (min_version_root_virtual_offset.in_fast_list() &&
+            max_version > min_version) {
+            avg_disk_growth_fast = divide_and_round(
+                curr_fast_writer_offset -
+                    compact_virtual_chunk_offset_t{
+                        min_version_root_virtual_offset},
+                max_version - min_version);
+        }
+        // Only advance the fast-list compaction offset if the uncompacted range
+        // exceeds min_versions_of_growth_before_compact_fast_list (5000)
+        // versions' worth of growth, to prevent over-compaction when the
+        // history window shrinks.
+        uint32_t const latest_block_fast_uncompacted_range =
+            curr_fast_writer_offset - compact_offsets.fast;
+        if (latest_block_fast_uncompacted_range >
+            static_cast<uint64_t>(avg_disk_growth_fast) *
+                min_versions_of_growth_before_compact_fast_list) {
+            // Stride that would evenly spread the uncompacted range across the
+            // history window, keeping fast-list disk usage steady over time.
+            uint32_t const target_fast_compaction_stride = divide_and_round(
+                latest_block_fast_uncompacted_range,
+                max_version - min_version + 1);
+            uint32_t to_advance = std::min(
+                target_fast_compaction_stride,
+                avg_disk_growth_fast + min_compaction_progress_buffer);
+            to_advance =
+                std::min(to_advance, max_compact_offset_range); // Cap at 32MB
+            compact_offset_range_fast_.set_value(to_advance);
+            compact_offsets.fast += compact_offset_range_fast_;
+        }
+    }
+    // <-- 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();
-    double const total_disk_usage = fast_disk_usage + slow_disk_usage;
     // Do not compact slow list until slow list usage and total usage are both
     // above the thresholds
-    if (total_disk_usage > usage_limit_start_compact_slow &&
+    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 =
+            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
-            uint32_t const new_range = std::min(
-                static_cast<uint32_t>(last_block_disk_growth_slow_ + 1),
-                last_block_slow_list_gc_efficiency_);
-            compact_offset_range_slow_.set_value(new_range);
-        }
-        else {
-            // No valid data, use minimum progress
-            compact_offset_range_slow_.set_value(1);
+            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_;
     }
-    else {
-        compact_offset_range_slow_ = MIN_COMPACT_VIRTUAL_OFFSET;
-    }
 }
 
 uint64_t UpdateAuxImpl::version_history_max_possible() const noexcept