Add an "epsilon" collector that never collects memory

This replaces the "dummy_impl"

Name inspired by JEP 318: https://openjdk.java.net/jeps/318

Author: Techcable

Cargo.toml

@@ -19,12 +19,14 @@ parking_lot = { version = "0.11", optional = true }
 serde = { version = "1", optional = true, features = ["derive"] }
 # Used for macros
 zerogc-derive = { path = "libs/derive", version = "0.2.0-alpha.5" }
+# Used for the "epsilon" no-op collector
+bumpalo = { version = "3", optional = true }
 
 [workspace]
 members = ["libs/simple", "libs/derive", "libs/context"]
 
 [features]
-default = ["std"]
+default = ["std", "epsilon"]
 # Depend on the standard library (optional)
 #
 # This implements tracing for most standard library types.
@@ -35,4 +37,6 @@ std = ["alloc"]
 # This implements `Trace` for `Box` and collections like `Vec`
 alloc = []
 # Serde support
-serde1 = ["serde", "zerogc-derive/__serde-internal"]
+serde1 = ["serde", "zerogc-derive/__serde-internal", "indexmap/serde-1"]
+# Support the "epsilon" no-op collector
+epsilon = ["bumpalo"]

libs/context/src/collector.rs

@@ -15,6 +15,7 @@ use crate::{CollectorContext};
 use crate::state::{CollectionManager, RawContext};
 use zerogc::vec::GcVec;
 use zerogc::vec::repr::GcVecRepr;
+use std::hash::{Hasher, Hash};
 
 /// A specific implementation of a collector
 pub unsafe trait RawCollectorImpl: 'static + Sized {
@@ -112,6 +113,12 @@ impl<C: RawCollectorImpl> PartialEq for CollectorId<C> {
         self.ptr == other.ptr
     }
 }
+impl<C: RawCollectorImpl> Hash for CollectorId<C>  {
+    #[inline]
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        hasher.write_usize(self.ptr.as_ptr() as usize);
+    }
+}
 impl<C: RawCollectorImpl> Eq for CollectorId<C> {}
 impl<C: RawCollectorImpl> Clone for CollectorId<C> {
     #[inline]

libs/context/src/lib.rs

@@ -211,6 +211,11 @@ unsafe impl<C: RawCollectorImpl> GcContext for CollectorContext<C> {
         })
     }
 
+    #[inline]
+    fn system(&self) -> &'_ Self::System {
+        unsafe { (&*self.raw).collector_ref() }
+    }
+
     #[inline]
     fn id(&self) -> Self::Id {
         unsafe { (&*self.raw).collector() }.id()

libs/context/src/state/mod.rs

@@ -85,13 +85,21 @@ pub unsafe trait RawContext<C>: Debug + self::sealed::Sealed
     }
     /// Get a pointer to the shadow stack
     fn shadow_stack_ptr(&self) -> *mut ShadowStack<C>;
+    /// Get a reference to the collector as a [CollectorRef]
+    ///
+    /// ## Safety
+    /// Assumes the underlying collector is still valid.
+    unsafe fn collector_ref(&self) -> &'_ CollectorRef<C>;
     /// Get a reference to the collector,
     /// assuming that it's valid
     ///
     /// ## Safety
     /// Assumes that the underlying collector
     /// is still valid.
-    unsafe fn collector(&self) -> &C;
+    #[inline]
+    unsafe fn collector(&self) -> &C {
+        self.collector_ref().as_raw()
+    }
     fn state(&self) -> ContextState;
 }
 

libs/context/src/state/nosync.rs

@@ -188,8 +188,8 @@ unsafe impl<C> super::RawContext<C> for RawContext<C>
     }
 
     #[inline]
-    unsafe fn collector(&self) -> &C {
-        self.collector.as_raw()
+    unsafe fn collector_ref(&self) -> &CollectorRef<C> {
+        &self.collector
     }
 
     #[inline]

libs/context/src/state/sync.rs

@@ -296,8 +296,8 @@ unsafe impl<C> super::RawContext<C> for RawContext<C>
     }
 
     #[inline]
-    unsafe fn collector(&self) -> &C {
-        self.collector.as_raw()
+    unsafe fn collector_ref(&self) -> &CollectorRef<C> {
+        &self.collector
     }
 
     #[inline]

libs/derive/tests/basic.rs

@@ -1,7 +1,7 @@
 #![feature(
     arbitrary_self_types, // Used for `zerogc(mutable)`
 )]
-use zerogc::{Gc, CollectorId, Trace, GcSafe, NullTrace, dummy_impl::{self, DummyCollectorId}};
+use zerogc::{Gc, CollectorId, Trace, GcSafe, NullTrace, epsilon::{self, EpsilonCollectorId}};
 
 use zerogc_derive::{Trace, NullTrace};
 use zerogc::cell::GcCell;
@@ -10,10 +10,10 @@ use std::marker::PhantomData;
 #[derive(Trace)]
 #[zerogc(collector_ids(DummyCollectorId))]
 pub struct SpecificCollector<'gc> {
-    gc: Gc<'gc, i32, DummyCollectorId>,
-    rec: Gc<'gc, SpecificCollector<'gc>, DummyCollectorId>,
+    gc: Gc<'gc, i32, EpsilonCollectorId>,
+    rec: Gc<'gc, SpecificCollector<'gc>, EpsilonCollectorId>,
     #[zerogc(mutable)]
-    cell: GcCell<Gc<'gc, SpecificCollector<'gc>, DummyCollectorId>>
+    cell: GcCell<Gc<'gc, SpecificCollector<'gc>, EpsilonCollectorId>>
 }
 
 #[derive(Trace)]
@@ -98,13 +98,13 @@ struct UnsafeSkipped<'gc> {
     s: &'static str,
     i: i32,
     #[zerogc(unsafe_skip_trace)]
-    wow: Gc<'gc, i32, DummyCollectorId>
+    wow: Gc<'gc, i32, EpsilonCollectorId>
 }
 
 #[derive(Trace)]
 #[zerogc(ignore_lifetimes("'a"), immutable, collector_ids(DummyCollectorId))]
 #[allow(unused)]
-struct LifetimeTrace<'a: 'gc, 'gc, T: GcSafe<'gc, DummyCollectorId> + 'a> {
+struct LifetimeTrace<'a: 'gc, 'gc, T: GcSafe<'gc, EpsilonCollectorId> + 'a> {
     s: String,
     i: i32,
     wow: Box<NopTrace>,
@@ -115,21 +115,21 @@ struct LifetimeTrace<'a: 'gc, 'gc, T: GcSafe<'gc, DummyCollectorId> + 'a> {
 
 #[test]
 fn basic<'gc>() {
-    let _b = Basic::<dummy_impl::DummyCollectorId> {
+    let _b = Basic::<epsilon::EpsilonCollectorId> {
         value: String::new(),
         parent: None,
         children: vec![],
         cell: GcCell::new(None)
     };
-    assert!(<Basic::<dummy_impl::DummyCollectorId> as Trace>::NEEDS_TRACE);
-    assert!(<BasicCopy::<dummy_impl::DummyCollectorId> as Trace>::NEEDS_TRACE);
-    assert!(<Basic::<dummy_impl::DummyCollectorId> as Trace>::NEEDS_DROP);
-    assert!(!<BasicCopy::<dummy_impl::DummyCollectorId> as Trace>::NEEDS_DROP);
-    assert_copy::<BasicCopy::<dummy_impl::DummyCollectorId>>();
+    assert!(<Basic::<epsilon::EpsilonCollectorId> as Trace>::NEEDS_TRACE);
+    assert!(<BasicCopy::<epsilon::EpsilonCollectorId> as Trace>::NEEDS_TRACE);
+    assert!(<Basic::<epsilon::EpsilonCollectorId> as Trace>::NEEDS_DROP);
+    assert!(!<BasicCopy::<epsilon::EpsilonCollectorId> as Trace>::NEEDS_DROP);
+    assert_copy::<BasicCopy::<epsilon::EpsilonCollectorId>>();
     assert_null_trace::<NopTrace>();
     assert!(!<NopTrace as Trace>::NEEDS_TRACE);
 
-    check_id::<dummy_impl::DummyCollectorId>();
+    check_id::<epsilon::EpsilonCollectorId>();
 
     // We explicitly skipped the only trace field
     assert!(!<UnsafeSkipped<'gc> as Trace>::NEEDS_TRACE);

libs/derive/tests/deserialize.rs

@@ -2,12 +2,12 @@ use zerogc_derive::{GcDeserialize, Trace};
 
 use zerogc::SimpleAllocCollectorId;
 use zerogc::prelude::*;
-use zerogc::dummy_impl::{DummyCollectorId};
+use zerogc::epsilon::{EpsilonCollectorId};
 
 #[derive(Trace, GcDeserialize)]
 #[zerogc(collector_ids(DummyCollectorId))]
 struct BasicDeserialize<'gc> {
-    test: Gc<'gc, String, DummyCollectorId>
+    test: Gc<'gc, String, EpsilonCollectorId>
 }
 
 #[derive(Trace, GcDeserialize)]

libs/simple/src/layout.rs

@@ -266,6 +266,11 @@ impl<'gc, T: GcSafe<'gc, crate::CollectorId>> SimpleVecRepr<'gc, T> {
     #[inline]
     fn header(&self) -> *mut GcVecHeader {
         unsafe {
+            /*
+             * TODO: what if we have a non-standard alignment?\
+             * Our `T` is erased at runtime....
+             * this is a bug in the epsilon collector too
+             */
             (self as *const Self as *mut Self as *mut u8)
                 .sub(GcVecHeader::LAYOUT.value_offset(std::mem::align_of::<T>()))
                 .cast()
@@ -279,7 +284,14 @@ unsafe impl<'gc, T: GcSafe<'gc, crate::CollectorId>> GcVecRepr<'gc> for SimpleVe
 
     #[inline]
     fn element_layout(&self) -> Layout {
-        Layout::new::<T>()
+        unsafe {
+            match (*self.header()).common_header.type_info.layout {
+                GcTypeLayout::Vec {
+                    element_layout, ..
+                } => element_layout,
+                _ => std::hint::unreachable_unchecked()
+            }
+        }
     }
 
     #[inline]