gc: the PYPY_GC_DEBUG nurseries, a debug_check_consistency with a body, gc.get_count's second element, and the comments that outran the code

majit/gate-triage.md

@@ -212,7 +212,7 @@ cover the condition they diagnose.
 
 - Read sites: 2 — `majit/majit-gc/src/nursery.rs`, `majit/majit-gc/src/oldgen.rs`
 - Accessor: `new()`
-- What it does: **UNRECORDED** — no doc comment describes the gate. Read off the sites, not quoted: the two reads initialise `poison_on_reset` (`nursery.rs`) and `poison_on_alloc` (`oldgen.rs`).
+- What it does: fill recycled nursery and old-gen memory with a poison word instead of zeroes, so an allocation path that relies on its memory arriving zeroed fails where it reads rather than later. The two reads initialise `poison_on_reset` (`nursery.rs`) and `poison_on_alloc` (`oldgen.rs`). The nursery half of this is upstream's `gc_nursery_debug` (`PYPY_GC_NURSERY_DEBUG`), which selects `arena_reset` mode 3; that name is read separately and additively, so either spelling turns the fill on and neither turns the other off.
 - Retirement condition: **UNRECORDED** — owed by this gate's owner.
 
 ### `MAJIT_GC_STRESS`

majit/majit-backend-cranelift/src/compiler.rs

@@ -482,7 +482,7 @@ fn register_active_hooks(supports_guard_gc_type: bool) {
         alloc_nursery_collecting_typed_rooted_via_active_runtime,
     ));
     majit_gc::set_active_alloc_oldgen_typed(Some(alloc_oldgen_typed_via_active_runtime));
-    majit_gc::set_active_collect_full(Some(collect_full_via_active_runtime));
+    majit_gc::set_active_collect_generation(Some(collect_generation_via_active_runtime));
     majit_gc::set_active_collect_step(Some(collect_step_via_active_runtime));
     majit_gc::set_active_get_objects(Some(get_objects_via_active_runtime));
     majit_gc::set_active_get_referents(Some(get_referents_via_active_runtime));
@@ -501,6 +501,9 @@ fn register_active_hooks(supports_guard_gc_type: bool) {
     majit_gc::set_active_heap_stats(Some(heap_stats_via_active_runtime));
     majit_gc::set_active_gc_memory_stats(Some(gc_memory_stats_via_active_runtime));
     majit_gc::set_active_major_threshold_reached(Some(major_threshold_reached_via_active_runtime));
+    majit_gc::set_active_minor_collections_since_major(Some(
+        minor_collections_since_major_via_active_runtime,
+    ));
     majit_gc::set_active_root_hooks(
         Some(gc_add_root_via_active_runtime),
         Some(gc_remove_root_via_active_runtime),
@@ -1852,13 +1855,13 @@ fn alloc_oldgen_typed_via_active_runtime(type_id: u32, size: usize) -> GcRef {
     with_cranelift_gc(|gc| gc.alloc_oldgen_typed(type_id, size)).unwrap_or(GcRef(0))
 }
 
-/// User-level `gc.collect()` trampoline — drives `GcAllocator::collect_full`
-/// on the active cranelift-owned GC. Mirrors the dynasm equivalent;
+/// User-level `gc.collect(n)` trampoline — drives
+/// `GcAllocator::collect_generation` on the active cranelift-owned GC. Mirrors the dynasm equivalent;
 /// safety constraints apply (caller must be at a safepoint where every
 /// live PyObjectRef is rooted — Rust-stack PyObjectRef in nursery would
 /// dangle after the embedded minor cycle).
-fn collect_full_via_active_runtime() {
-    with_cranelift_gc(|gc| gc.collect_full());
+fn collect_generation_via_active_runtime(generation: i64) {
+    with_cranelift_gc(|gc| gc.collect_generation(generation));
 }
 
 fn collect_step_via_active_runtime() -> majit_gc::GcStepTransition {
@@ -1985,7 +1988,7 @@ fn total_memory_pressure_via_active_runtime() -> isize {
 
 /// Non-moving old-gen-only major trampoline — sweeps dead old-gen objects
 /// without moving the nursery, so the interpreter safepoint can drive it under
-/// an active JIT (non-empty nursery). Unlike [`collect_full_via_active_runtime`]
+/// an active JIT (non-empty nursery). Unlike [`collect_generation_via_active_runtime`]
 /// it runs no minor, so a Rust-stack nursery PyObjectRef cannot dangle.
 fn collect_oldgen_nonmoving_via_active_runtime() {
     with_cranelift_gc(|gc| gc.collect_oldgen_nonmoving());
@@ -2018,6 +2021,10 @@ fn major_threshold_reached_via_active_runtime() -> bool {
     with_cranelift_gc(|gc| gc.major_threshold_reached()).unwrap_or(false)
 }
 
+fn minor_collections_since_major_via_active_runtime() -> usize {
+    with_cranelift_gc(|gc| gc.minor_collections_since_major()).unwrap_or(0)
+}
+
 /// Host-side root-register trampoline. Bridges
 /// `majit_gc::gc_add_root` to the active cranelift-owned GC's
 /// `RootSet`.

majit/majit-backend-dynasm/src/runner.rs

@@ -329,7 +329,7 @@ fn register_active_hooks(supports_guard_gc_type: bool) {
         dynasm_alloc_nursery_collecting_typed_rooted,
     ));
     majit_gc::set_active_alloc_oldgen_typed(Some(dynasm_alloc_oldgen_typed));
-    majit_gc::set_active_collect_full(Some(dynasm_collect_full));
+    majit_gc::set_active_collect_generation(Some(dynasm_collect_generation));
     majit_gc::set_active_collect_step(Some(dynasm_collect_step));
     majit_gc::set_active_get_objects(Some(dynasm_get_objects));
     majit_gc::set_active_get_referents(Some(dynasm_get_referents));
@@ -348,6 +348,7 @@ fn register_active_hooks(supports_guard_gc_type: bool) {
     majit_gc::set_active_heap_stats(Some(dynasm_heap_stats));
     majit_gc::set_active_gc_memory_stats(Some(dynasm_gc_memory_stats));
     majit_gc::set_active_major_threshold_reached(Some(dynasm_major_threshold_reached));
+    majit_gc::set_active_minor_collections_since_major(Some(dynasm_minor_collections_since_major));
     majit_gc::set_active_root_hooks(Some(dynasm_gc_add_root), Some(dynasm_gc_remove_root));
     majit_gc::set_active_gc_owns_object(Some(dynasm_gc_owns_object));
     majit_gc::set_active_gc_is_nursery_object(Some(dynasm_gc_is_nursery_object));
@@ -659,18 +660,18 @@ fn bh_alloc_struct(sizedescr: &majit_translate::jitcode::BhDescr) -> *mut libc::
     ptr
 }
 
-/// User-level `gc.collect()` trampoline — drives `GcAllocator::collect_full`
-/// on the active dynasm-owned GC. PyPy's `pypy/module/gc/interp_gc.py:7-26`
-/// runs `rgc.collect()` from app-level `gc.collect`; this is the dynasm
-/// backend's edge of that path. Safety: callers must be at a safepoint
+/// User-level `gc.collect(n)` trampoline — drives
+/// `GcAllocator::collect_generation` on the active dynasm-owned GC.
+/// `interp_gc.py collect` runs `rgc.collect()` from app-level `gc.collect`;
+/// this is the dynasm backend's edge of that path. Safety: callers must be at a safepoint
 /// where every live PyObjectRef is either in a registered root, on the
 /// Python value stack, or on the shadow stack — Rust-stack PyObjectRef
 /// in nursery would dangle after the embedded minor cycle.
-fn dynasm_collect_full() {
-    if gc_box::with_mut(|g| g.collect_full()).is_some() {
+fn dynasm_collect_generation(generation: i64) {
+    if gc_box::with_mut(|g| g.collect_generation(generation)).is_some() {
         return;
     }
-    majit_gc::gc_sync::gc_op(|g| g.collect_full());
+    majit_gc::gc_sync::gc_op(|g| g.collect_generation(generation));
 }
 
 fn dynasm_collect_step() -> majit_gc::GcStepTransition {
@@ -807,7 +808,7 @@ fn dynasm_total_memory_pressure() -> isize {
 
 /// Non-moving old-gen-only major. Reclaims stable-allocated interp int/float
 /// without moving the nursery, so the interpreter safepoint can fire it under
-/// an active JIT (nursery non-empty) — unlike [`dynasm_collect_full`], whose
+/// an active JIT (nursery non-empty) — unlike [`dynasm_collect_generation`], whose
 /// embedded minor would relocate a Rust-stack nursery PyObjectRef.
 fn dynasm_collect_oldgen_nonmoving() {
     if gc_box::with_mut(|g| g.collect_oldgen_nonmoving()).is_some() {
@@ -848,6 +849,13 @@ fn dynasm_major_threshold_reached() -> bool {
     majit_gc::gc_sync::gc_op(|g| g.major_threshold_reached())
 }
 
+fn dynasm_minor_collections_since_major() -> usize {
+    if let Some(r) = gc_box::with_mut(|g| g.minor_collections_since_major()) {
+        return r;
+    }
+    majit_gc::gc_sync::gc_op(|g| g.minor_collections_since_major())
+}
+
 /// Host-side root-register trampoline. Bridges
 /// `majit_gc::gc_add_root` to the active backend's `RootSet`.
 ///

majit/majit-backend-wasm/src/lib.rs

@@ -1011,12 +1011,15 @@ fn register_active_hooks(supports_guard_gc_type: bool) {
     majit_gc::set_active_get_typeids_list(Some(wasm_get_typeids_list));
     majit_gc::set_active_add_memory_pressure(Some(wasm_add_memory_pressure));
     majit_gc::set_active_total_memory_pressure(Some(wasm_total_memory_pressure));
-    majit_gc::set_active_collect_full(Some(wasm_collect_full));
+    majit_gc::set_active_collect_generation(Some(wasm_collect_generation));
     majit_gc::set_active_collect_step(Some(wasm_collect_step));
     majit_gc::set_active_collect_oldgen(Some(wasm_collect_oldgen_nonmoving));
     majit_gc::set_active_heap_stats(Some(active_gc_heap_stats));
     majit_gc::set_active_gc_memory_stats(Some(active_gc_memory_stats));
     majit_gc::set_active_major_threshold_reached(Some(active_gc_major_threshold_reached));
+    majit_gc::set_active_minor_collections_since_major(Some(
+        active_gc_minor_collections_since_major,
+    ));
     majit_gc::set_active_finalizer_hooks(
         Some(wasm_register_finalizer),
         Some(wasm_finalizer_next_dead),
@@ -1069,6 +1072,12 @@ pub fn active_gc_major_threshold_reached() -> bool {
     with_wasm_active_gc(|gc| gc.major_threshold_reached()).unwrap_or(false)
 }
 
+/// Minor collections the active GC has run since its last major, or `0` when
+/// none is installed.
+pub fn active_gc_minor_collections_since_major() -> usize {
+    with_wasm_active_gc(|gc| gc.minor_collections_since_major()).unwrap_or(0)
+}
+
 /// Diagnostic: `(minor_collections, major_collections)` of the active GC, or
 /// `(0, 0)` when none is installed. Companion to [`active_gc_heap_stats`].
 pub fn active_gc_collection_counts() -> (usize, usize) {
@@ -1169,16 +1178,17 @@ fn jf_top_addr() -> Option<u32> {
         .filter(|&addr| addr != 0)
 }
 
-/// `majit_gc::CollectFullFn` installed by `register_active_hooks`. Drives
-/// `gc.collect()` (`interp_gc.py`) through the active GC. Without it
-/// `majit_gc::collect_full` has no hook to dispatch to and silently returns,
+/// `majit_gc::CollectGenerationFn` installed by `register_active_hooks`. Drives
+/// `gc.collect(n)` (`interp_gc.py`) through the active GC. Without it
+/// `majit_gc::collect_generation` has no hook to dispatch to and silently
+/// returns,
 /// so no major cycle ever runs on this backend and
 /// `deal_with_objects_with_finalizers` — which lives inside the major — never
 /// executes: no `__del__`, no generator `finally`, not even under an explicit
-/// `gc.collect()`. Mirrors dynasm's `dynasm_collect_full` and cranelift's
-/// `collect_full_via_active_runtime`.
-fn wasm_collect_full() {
-    with_wasm_active_gc_mut(|gc| gc.collect_full());
+/// `gc.collect()`. Mirrors dynasm's `dynasm_collect_generation` and cranelift's
+/// `collect_generation_via_active_runtime`.
+fn wasm_collect_generation(generation: i64) {
+    with_wasm_active_gc_mut(|gc| gc.collect_generation(generation));
 }
 
 fn wasm_collect_step() -> majit_gc::GcStepTransition {

majit/majit-gc/Cargo.toml

@@ -42,5 +42,11 @@ indexmap = { workspace = true }
 libc = { workspace = true }
 majit-ir = { workspace = true }
 
+# `llarena.arena_protect` is posix `mprotect` and nt `VirtualProtect`;
+# `llarena.has_protect` is false everywhere else, which is why this is not a
+# dependency of the wasm32 build.
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+region = { workspace = true }
+
 [dev-dependencies]
 majit-ir = { workspace = true, features = ["test-support"] }