add benchmark for arena2 vs boa gc

Author: shruti2522

notes/arena2_vs_boa_gc.md

@@ -0,0 +1,42 @@
+# arena2 vs boa_gc benchmark results
+
+Note author: shruti2522
+date: 2026-03-06
+
+This benchmark measures how the `arena2` allocator which uses a simple bump allocator with `TaggedPtr` headers for liveness compares against the standard `boa_gc` implementation
+
+Ran the `arena2_vs_boa_gc` bench suite. It compares oscars' `arena2` against `boa_gc` across node allocation, collection pauses, mixed workloads, and memory pressure.
+
+## Results
+
+### gc_node_allocation
+
+arena2 heavily outperforms boa_gc across all sizes.
+- **10 nodes:** arena2 takes ~320 ns vs ~750 ns for boa_gc
+- **100 nodes:** arena2 takes ~3.2 µs vs ~6.4 µs for boa_gc
+- **1000 nodes:** arena2 takes ~27.3 µs vs ~56.2 µs  for boa_gc
+
+This shows that bump allocation into an arena page is consistently more than 2x faster than whatever the standard boa_gc is doing.
+
+### gc_collection_pause
+
+Similar to allocations, the sweep phase in arena2 is extremely fast compared to boa_gc.
+- **100 objects:** arena2 sweeps in ~3.5 µs vs ~7.3 µs for boa_gc
+- **500 objects:** arena2 sweeps in ~15.2 µs vs ~32.5 µs for boa_gc
+- **1000 objects:** arena2 sweeps in ~29.5 µs vs ~74.9 µs for boa_gc
+
+The linear scan over the contiguous blocks in arena2 during garbage collection cuts the pause times by more than half.
+
+### mixed_workload
+
+This tests repeated allocations spread around `collect()` pauses.
+Both allocators performed similarly here. arena2 took ~17.8 µs and boa_gc took ~17.8 µs. So arena2's big speed advantage seems to even out when allocations and collections are mixed together.
+
+### memory_pressure
+
+This tests creating and deleting many objects quickly (make 50, keep 5, collect, repeat 10 times).
+both allocators are equally fast here. arena2 took ~46.0 µs and boa_gc took ~46.6 µs. The cost of throwing away whole memory pages versus single objects seems to balance out
+
+## Conclusion
+
+`arena2` is much faster for simple allocations and collection sweeps, about twice as fast. In mixed tests and heavy memory tests, they perform about the same.

oscars/Cargo.toml

@@ -23,6 +23,10 @@ required-features = ["gc_allocator"]
 name = "arena2_vs_arena3"
 harness = false
 
+[[bench]]
+name = "arena2_vs_boa_gc"
+harness = false
+
 [features]
 default = ["mark_sweep"]
 std = []

oscars/benches/arena2_vs_boa_gc.rs

@@ -0,0 +1,192 @@
+use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main};
+use oscars::collectors::mark_sweep_arena2::{
+    Finalize, Gc as OscarsGc, MarkSweepGarbageCollector, Trace, TraceColor,
+    cell::GcRefCell as OscarsGcRefCell,
+};
+
+use boa_gc::{Gc as BoaGc, GcRefCell as BoaGcRefCell, force_collect as boa_force_collect};
+
+fn bench_alloc(c: &mut Criterion) {
+    let mut group = c.benchmark_group("gc_node_allocation");
+
+    for size in [10, 100, 1000].iter() {
+        group.bench_with_input(BenchmarkId::new("arena2", size), size, |b, &size| {
+            let collector = MarkSweepGarbageCollector::default()
+                .with_arena_size(65536)
+                .with_heap_threshold(262144);
+
+            b.iter(|| {
+                let mut roots = Vec::new();
+                for i in 0..size {
+                    let root = OscarsGc::new_in(OscarsGcRefCell::new(i), &collector);
+                    roots.push(root);
+                }
+                black_box(roots.len())
+            });
+        });
+
+        group.bench_with_input(BenchmarkId::new("boa_gc", size), size, |b, &size| {
+            b.iter_batched(
+                || {
+                    boa_force_collect();
+                },
+                |()| {
+                    let mut gcs = Vec::new();
+                    for i in 0..size {
+                        let gc = BoaGc::new(BoaGcRefCell::new(i));
+                        gcs.push(gc);
+                    }
+                    black_box(gcs.len())
+                },
+                criterion::BatchSize::SmallInput,
+            );
+        });
+    }
+
+    group.finish();
+}
+
+fn bench_collection(c: &mut Criterion) {
+    let mut group = c.benchmark_group("gc_collection_pause");
+
+    for size in [100, 500, 1000].iter() {
+        group.bench_with_input(BenchmarkId::new("arena2", size), size, |b, &size| {
+            let collector = MarkSweepGarbageCollector::default()
+                .with_arena_size(65536)
+                .with_heap_threshold(262144);
+
+            b.iter(|| {
+                let mut roots = Vec::new();
+                for i in 0..size {
+                    let root = OscarsGc::new_in(OscarsGcRefCell::new(i), &collector);
+                    roots.push(root);
+                }
+                // let half be garbage
+                roots.truncate(size / 2);
+                collector.collect();
+                black_box(roots.len())
+            });
+        });
+
+        group.bench_with_input(BenchmarkId::new("boa_gc", size), size, |b, &size| {
+            b.iter(|| {
+                let mut gcs = Vec::new();
+                for i in 0..size {
+                    let gc = BoaGc::new(BoaGcRefCell::new(i));
+                    gcs.push(gc);
+                }
+                gcs.truncate(size / 2);
+                boa_force_collect();
+                black_box(gcs.len())
+            });
+        });
+    }
+
+    group.finish();
+}
+
+fn bench_mixed(c: &mut Criterion) {
+    let mut group = c.benchmark_group("mixed_workload");
+
+    group.bench_function("arena2", |b| {
+        let collector = MarkSweepGarbageCollector::default()
+            .with_arena_size(65536)
+            .with_heap_threshold(131072);
+
+        b.iter(|| {
+            let mut roots = Vec::new();
+
+            for i in 0..100 {
+                let root = OscarsGc::new_in(OscarsGcRefCell::new(i), &collector);
+                roots.push(root);
+            }
+            collector.collect();
+
+            for i in 100..200 {
+                let root = OscarsGc::new_in(OscarsGcRefCell::new(i), &collector);
+                roots.push(root);
+            }
+            collector.collect();
+
+            black_box(roots.len())
+        });
+    });
+
+    group.bench_function("boa_gc", |b| {
+        b.iter(|| {
+            let mut gcs = Vec::new();
+
+            for i in 0..100 {
+                let gc = BoaGc::new(BoaGcRefCell::new(i));
+                gcs.push(gc);
+            }
+            boa_force_collect();
+
+            for i in 100..200 {
+                let gc = BoaGc::new(BoaGcRefCell::new(i));
+                gcs.push(gc);
+            }
+            boa_force_collect();
+
+            black_box(gcs.len())
+        });
+    });
+
+    group.finish();
+}
+
+fn bench_pressure(c: &mut Criterion) {
+    let mut group = c.benchmark_group("memory_pressure");
+
+    group.bench_function("arena2", |b| {
+        let collector = MarkSweepGarbageCollector::default()
+            .with_arena_size(32768)
+            .with_heap_threshold(65536);
+
+        b.iter(|| {
+            let mut live = Vec::new();
+
+            for round in 0..10 {
+                for i in 0..50 {
+                    let obj = OscarsGc::new_in(OscarsGcRefCell::new(round * 100 + i), &collector);
+                    if i % 10 == 0 {
+                        live.push(obj);
+                    }
+                }
+                collector.collect();
+            }
+
+            black_box(live.len())
+        });
+    });
+
+    group.bench_function("boa_gc", |b| {
+        b.iter(|| {
+            let mut live = Vec::new();
+
+            for round in 0..10 {
+                for i in 0..50 {
+                    let obj = BoaGc::new(BoaGcRefCell::new(round * 100 + i));
+                    if i % 10 == 0 {
+                        live.push(obj);
+                    }
+                }
+                boa_force_collect();
+            }
+
+            black_box(live.len())
+        });
+    });
+
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    bench_alloc,
+    bench_collection,
+    bench_mixed,
+    bench_pressure,
+);
+
+criterion_main!(benches);

oscars/src/alloc/arena2/alloc.rs

@@ -44,7 +44,7 @@ impl<T: ?Sized> ArenaHeapItem<T> {
         &mut self.value as *mut T
     }
 
-    fn value_mut(&mut self) -> &mut T {
+    pub(crate) fn value_mut(&mut self) -> &mut T {
         &mut self.value
     }
 }

oscars/src/alloc/arena2/tests.rs

@@ -77,7 +77,7 @@ fn arc_drop() {
         let heap_item_mut = heap_item.as_mut();
         // Manually drop the heap item
         heap_item_mut.mark_dropped();
-        drop_in_place(heap_item_mut.as_ptr());
+        drop_in_place(heap_item_mut.value_mut());
     };
 
     assert!(dropped.load(Ordering::SeqCst));

oscars/src/collectors/mark_sweep/internals/gc_box.rs

@@ -44,11 +44,11 @@ impl<T: Trace + Finalize + ?Sized> WeakGcBox<T> {
     }
 
     pub(crate) fn erased_inner_ptr(&self) -> NonNull<GcBox<NonTraceable>> {
-        // SAFETY: `as_heap_ptr` returns a valid pointer to
-        // `ArenaHeapItem` whose lifetime is tied to the arena
-        let heap_item = unsafe { self.as_heap_ptr().as_mut() };
-        // SAFETY: We just removed this value from a NonNull
-        unsafe { NonNull::new_unchecked(heap_item.as_ptr()) }
+        use crate::alloc::arena3::ArenaHeapItem;
+        // SAFETY: `ArenaHeapItem` is `repr(transparent)`, use addr_of_mut! to avoid
+        // creating a &mut reference during trace
+        let raw: *mut ArenaHeapItem<GcBox<NonTraceable>> = self.as_heap_ptr().as_ptr();
+        unsafe { NonNull::new_unchecked(core::ptr::addr_of_mut!((*raw).0)) }
     }
 
     pub(crate) fn as_heap_ptr(&self) -> NonNull<ArenaHeapItem<GcBox<NonTraceable>>> {

oscars/src/collectors/mark_sweep/pointers/gc.rs

@@ -44,8 +44,12 @@ impl<T: Trace> Gc<T> {
 
 impl<T: Trace + ?Sized> Gc<T> {
     pub(crate) fn as_sized_inner_ptr(&self) -> NonNull<GcBox<NonTraceable>> {
-        let heap_item = unsafe { self.as_heap_ptr().as_mut() };
-        unsafe { NonNull::new_unchecked(heap_item.as_ptr()) }
+        // SAFETY: use `addr_of_mut!` to get a raw pointer without creating
+        // a `&mut` reference, avoiding Stacked Borrows UB during GC tracing
+        let raw: *mut ArenaHeapItem<GcBox<NonTraceable>> = self.as_heap_ptr().as_ptr();
+        // SAFETY: `raw` is non-null because it comes from `as_heap_ptr()`
+        // `ArenaHeapItem` is `#[repr(transparent)]` so it shares the same address as field 0
+        unsafe { NonNull::new_unchecked(core::ptr::addr_of_mut!((*raw).0)) }
     }
 
     pub(crate) fn as_heap_ptr(&self) -> NonNull<ArenaHeapItem<GcBox<NonTraceable>>> {

oscars/src/collectors/mark_sweep/tests.rs

@@ -445,6 +445,10 @@ mod gc_edge_cases {
             next: Option<Gc<Node>>,
         }
 
+        #[cfg(miri)]
+        const DEPTH: usize = 20;
+
+        #[cfg(not(miri))]
         const DEPTH: usize = 1_000;
 
         let mut head = Gc::new_in(Node { _id: 0, next: None }, collector);
@@ -613,6 +617,10 @@ mod gc_edge_cases {
             next: Option<Gc<Chain>>,
         }
 
+        #[cfg(miri)]
+        const LEN: usize = 20;
+
+        #[cfg(not(miri))]
         const LEN: usize = 500;
 
         let mut head = Gc::new_in(Chain { next: None }, collector);

oscars/src/collectors/mark_sweep_arena2/README.md

@@ -0,0 +1,21 @@
+# Mark sweep collector
+
+This is a basic mark-sweep collector using an underlying arena allocator.
+
+## TODO list
+
+- [x] Support weak maps
+- [x] Add Tests
+
+
+## Areas of improvement
+
+The overhead on a single allocation honestly feels a bit high. This may be worthwhile
+for now for performance gains and general API, but we should really measure and determine
+just how much overhead is being added.
+
+Currently, there is a line drawn between the allocator and the GcBox. This creates very,
+very awkward naming (ArenaPointer, ArenaHeapItem, GcBox, etc.). We may be able to combine
+the general functionality of the ArenaHeapItem, and GcBox. But also, that would then
+restrict the potential ability to switch out allocators as easily ... to be determined.
+