fix(gc): scope the retaining band to the full-collection decision, not survivor placement

gc-ratchet 11_collect_at_depth turned 6,150 promoted objects into 6,139 copied
ones: copied_minor_promotion_handoff_pressure_due shares old_reclaim_pressure_due
with the OldReclaim escalation, so widening the shared band also stopped the
survivor-promotion handoff from firing on a retaining heap. Placement and
collection are different questions and only the second one was paying for a
futile full, so the multiplier moves to old_reclaim_full_due and the shared band
goes back to what it was. Pinned by a test that asserts both directions from one
reading.

Author: Ralph Küpper

crates/perry-runtime/src/gc/policy.rs

@@ -1351,25 +1351,45 @@ const OLD_RECLAIM_GROWTH_DIVISOR: usize = 2;
 /// the "is it due" predicate and the debt arithmetic cannot diverge (#7024's
 /// two-predicates-collapse family).
 pub(super) fn gc_old_reclaim_growth_band_bytes(baseline: usize) -> usize {
-    let band = gc_old_gen_reclaim_growth_dyn_bytes().max(baseline / OLD_RECLAIM_GROWTH_DIVISOR);
-    // Survival-adaptive, the same signal and the same multiplier the
-    // arena-growth escalation uses (`MAJOR_PACING_RETAINING_GROWTH_MULTIPLIER`).
-    //
-    // `credit_promoted_bytes_to_old_baseline` already exempts old-gen growth
-    // that a minor PROVED live, but a large object is allocated straight into
-    // old-gen and never passes through promotion, so its bytes are uncredited
-    // growth even when they are the program's live data. On `retain.ts` that is
-    // the element array itself: with the arena-growth escalation correctly
-    // declining, this band became the binding constraint and fired a 452 ms
-    // full that reclaimed 7.6% — the same futile-full shape one trigger over,
-    // reached by the same route. While the young generation is not dying, old
-    // growth is priced as live here too.
+    gc_old_gen_reclaim_growth_dyn_bytes().max(baseline / OLD_RECLAIM_GROWTH_DIVISOR)
+}
+
+/// The same band, widened while the heap is RETAINING, for the decisions that
+/// answer **"run a FULL collection now?"**.
+///
+/// `credit_promoted_bytes_to_old_baseline` already exempts old-gen growth that
+/// a minor PROVED live, but a large object is allocated straight into old-gen
+/// and never passes through promotion, so its bytes are uncredited growth even
+/// when they are the program's live data. On `retain.ts` that is the element
+/// array itself: with the arena-growth escalation correctly declining, this
+/// band became the binding constraint and fired a 452 ms full that reclaimed
+/// 7.6% — the same futile-full shape one trigger over, reached by the same
+/// route.
+///
+/// **Deliberately not folded into `gc_old_reclaim_growth_band_bytes`.** That
+/// predicate has a second caller,
+/// `copied_minor_promotion_handoff_pressure_due`, which decides where a
+/// copying minor's survivors LIVE — not whether to collect. Widening it there
+/// too made the handoff stop firing on a retaining heap, and the gc-ratchet's
+/// `11_collect_at_depth` recorded exactly that: 6,150 promoted objects became
+/// 6,139 copied ones. Placement and collection are different questions and only
+/// the second one is paying for a futile full.
+fn old_reclaim_full_growth_band_bytes(baseline: usize) -> usize {
+    let band = gc_old_reclaim_growth_band_bytes(baseline);
     if GC_MAJOR_PACING_RETAINING.with(|c| c.get()) {
         return band.saturating_mul(MAJOR_PACING_RETAINING_GROWTH_MULTIPLIER);
     }
     band
 }
 
+/// [`old_reclaim_pressure_due`] for the callers that respond by running a full
+/// collection. Same shape, retaining-adaptive band.
+pub(super) fn old_reclaim_full_due(old_in_use: usize, baseline: usize) -> bool {
+    (old_in_use >= gc_old_gen_reclaim_threshold_dyn_bytes()
+        && baseline < gc_old_gen_reclaim_threshold_dyn_bytes())
+        || old_in_use.saturating_sub(baseline) >= old_reclaim_full_growth_band_bytes(baseline)
+}
+
 #[inline]
 pub(super) fn old_reclaim_pressure_due(old_in_use: usize, baseline: usize) -> bool {
     (old_in_use >= gc_old_gen_reclaim_threshold_dyn_bytes()
@@ -1576,7 +1596,9 @@ pub(super) fn maybe_schedule_old_reclaim_after_copied_minor() {
     let old_in_use =
         old_gen_reclaimable_pressure_bytes().saturating_add(external_side_live_bytes());
     let baseline = GC_LAST_OLD_RECLAIM_IN_USE_BYTES.with(|bytes| bytes.get());
-    if old_reclaim_pressure_due(old_in_use, baseline) {
+    // `_full_due`: this schedules a FULL collection, so it reads the
+    // retaining-adaptive band. The survivor-placement caller does not.
+    if old_reclaim_full_due(old_in_use, baseline) {
         GC_OLD_RECLAIM_PENDING.with(|pending| pending.set(true));
     }
 }
@@ -2453,7 +2475,7 @@ fn gc_budgeted_due_trigger() -> Option<BudgetedGcTrigger> {
     let old_in_use =
         old_gen_reclaimable_pressure_bytes().saturating_add(external_side_live_bytes());
     let old_baseline = GC_LAST_OLD_RECLAIM_IN_USE_BYTES.with(|bytes| bytes.get());
-    if old_pending || old_reclaim_pressure_due(old_in_use, old_baseline) {
+    if old_pending || old_reclaim_full_due(old_in_use, old_baseline) {
         return Some(BudgetedGcTrigger::OldReclaim);
     }
 

crates/perry-runtime/src/gc/tests/triggers.rs

@@ -1339,3 +1339,58 @@ fn retaining_rebaseline_never_lowers_the_pacing_baseline() {
         "a larger post-minor occupancy must raise it"
     );
 }
+
+/// The retaining band must widen the FULL-collection decision and leave the
+/// survivor-PLACEMENT decision alone.
+///
+/// These two read the same numbers through predicates that used to be one, and
+/// collapsing them is not hypothetical: widening the shared band made
+/// `copied_minor_promotion_handoff_pressure_due` stop firing on a retaining
+/// heap, and the gc-ratchet's `11_collect_at_depth` turned 6,150 promoted
+/// objects into 6,139 copied ones. So the divergence is pinned rather than
+/// left as a convention.
+#[test]
+fn the_retaining_band_widens_the_full_decision_but_not_survivor_placement() {
+    use super::super::policy::{
+        gc_old_reclaim_growth_band_bytes, note_copying_minor_young_survival, old_reclaim_full_due,
+        old_reclaim_pressure_due, test_reset_major_pacing_backoff, test_set_pacing_arena_in_use,
+    };
+
+    // Pacing's re-baseline reads the arena; pin it so this test only moves the
+    // retaining flag.
+    let previous_reading = test_set_pacing_arena_in_use(Some(0));
+    test_reset_major_pacing_backoff();
+
+    // A baseline high enough that the proportional band, not the constant
+    // floor, decides — and an `old_in_use` inside `(band, 4 × band]`.
+    let baseline = 512 * 1024 * 1024;
+    let band = gc_old_reclaim_growth_band_bytes(baseline);
+    let old_in_use = baseline + band + 1;
+
+    note_copying_minor_young_survival(0);
+    let off_full = old_reclaim_full_due(old_in_use, baseline);
+    let off_placement = old_reclaim_pressure_due(old_in_use, baseline);
+
+    note_copying_minor_young_survival(1000);
+    let on_full = old_reclaim_full_due(old_in_use, baseline);
+    let on_placement = old_reclaim_pressure_due(old_in_use, baseline);
+
+    test_set_pacing_arena_in_use(previous_reading);
+    test_reset_major_pacing_backoff();
+
+    assert!(
+        off_full && off_placement,
+        "without the retaining arm this reading must be due on both, or the \
+         test proves nothing"
+    );
+    assert!(
+        !on_full,
+        "a retaining heap must not schedule a full for old growth inside the \
+         widened band"
+    );
+    assert!(
+        on_placement,
+        "survivor placement must be unaffected: it decides where survivors \
+         live, not whether to collect"
+    );
+}