docs/ci: selfhost bootstrap/exe-first workflows; add ny-llvmc scaffolding + JSON v0 schema validation; plan: unify to Nyash ABI v2 (no backwards compat)

src/runtime/gc.rs

@@ -11,11 +11,13 @@ pub enum BarrierKind {
 
 /// GC hooks that execution engines may call at key points.
 /// Implementations must be Send + Sync for multi-thread preparation.
-pub trait GcHooks: Send + Sync {
+pub trait GcHooks: Send + Sync + std::any::Any {
     /// Safe point for cooperative GC (e.g., poll or yield).
     fn safepoint(&self) {}
     /// Memory barrier hint for loads/stores.
     fn barrier(&self, _kind: BarrierKind) {}
+    /// Allocation accounting (bytes are best-effort; may be 0 when unknown)
+    fn alloc(&self, _bytes: u64) {}
     /// Optional counters snapshot for diagnostics. Default: None.
     fn snapshot_counters(&self) -> Option<(u64, u64, u64)> {
         None
@@ -27,48 +29,35 @@ pub struct NullGc;
 
 impl GcHooks for NullGc {}
 
-use std::sync::atomic::{AtomicU64, Ordering};
-
-/// Simple counting GC (PoC): counts safepoints and barriers.
-/// Useful to validate hook frequency without affecting semantics.
+/// CountingGc is now a thin wrapper around the unified GcController.
 pub struct CountingGc {
-    pub safepoints: AtomicU64,
-    pub barrier_reads: AtomicU64,
-    pub barrier_writes: AtomicU64,
+    inner: crate::runtime::gc_controller::GcController,
 }
 
 impl CountingGc {
     pub fn new() -> Self {
+        // Default to rc+cycle mode for development metrics
+        let mode = crate::runtime::gc_mode::GcMode::RcCycle;
         Self {
-            safepoints: AtomicU64::new(0),
-            barrier_reads: AtomicU64::new(0),
-            barrier_writes: AtomicU64::new(0),
+            inner: crate::runtime::gc_controller::GcController::new(mode),
         }
     }
     pub fn snapshot(&self) -> (u64, u64, u64) {
-        (
-            self.safepoints.load(Ordering::Relaxed),
-            self.barrier_reads.load(Ordering::Relaxed),
-            self.barrier_writes.load(Ordering::Relaxed),
-        )
+        self.inner.snapshot()
     }
 }
 
 impl GcHooks for CountingGc {
     fn safepoint(&self) {
-        self.safepoints.fetch_add(1, Ordering::Relaxed);
+        self.inner.safepoint();
     }
     fn barrier(&self, kind: BarrierKind) {
-        match kind {
-            BarrierKind::Read => {
-                self.barrier_reads.fetch_add(1, Ordering::Relaxed);
-            }
-            BarrierKind::Write => {
-                self.barrier_writes.fetch_add(1, Ordering::Relaxed);
-            }
-        }
+        self.inner.barrier(kind);
+    }
+    fn alloc(&self, bytes: u64) {
+        self.inner.alloc(bytes);
     }
     fn snapshot_counters(&self) -> Option<(u64, u64, u64)> {
-        Some(self.snapshot())
+        Some(self.inner.snapshot())
     }
 }