Allow customizing whether GcArray is fat or thin

Switch the epsilon collector to use fat pointers for arrays,
so that it's easy to transmute back and forth to `&[T]`.
This allows us to remove that horrible `epsilon_static_array!` macro.

Futher lowers the overhead of the epsilon collector......

TODO: We should be able to eliminate most array headers
thanks to this......

Author: Techcable

libs/context/src/collector.rs

@@ -9,7 +9,7 @@ use alloc::sync::Arc;
 
 use slog::{Logger, o};
 
-use zerogc::{Gc, GcSafe, GcSystem, Trace, GcSimpleAlloc, NullTrace, TraceImmutable, GcVisitor, GcArray, TrustedDrop};
+use zerogc::{Gc, GcSafe, GcSystem, Trace, GcSimpleAlloc, NullTrace, TraceImmutable, GcVisitor,  TrustedDrop};
 
 use crate::{CollectorContext};
 use crate::state::{CollectionManager, RawContext};
@@ -52,10 +52,12 @@ pub unsafe trait RawCollectorImpl: 'static + Sized {
     fn id_for_gc<'a, 'gc, T>(gc: &'a Gc<'gc, T, CollectorId<Self>>) -> &'a CollectorId<Self>
         where 'gc: 'a, T: ?Sized + 'gc;
 
-    fn id_for_array<'a, 'gc, T>(gc: &'a GcArray<'gc, T, CollectorId<Self>>) -> &'a CollectorId<Self>
+    // TODO: What if we want to customize 'GcArrayRepr'??
+
+    fn id_for_array<'a, 'gc, T>(gc: &'a <CollectorId<Self> as zerogc::CollectorId>::ArrayRepr<'gc, T>) -> &'a CollectorId<Self>
         where 'gc: 'a, T: 'gc;
 
-    fn resolve_array_len<'gc, T>(gc: GcArray<'gc, T, CollectorId<Self>>) -> usize
+    fn resolve_array_len<'gc, T>(gc: <CollectorId<Self> as zerogc::CollectorId>::ArrayRepr<'gc, T>) -> usize
         where T: 'gc;
 
     /// Convert the specified value into a dyn pointer
@@ -291,19 +293,16 @@ impl<C: RawCollectorImpl> CollectorId<C> {
 unsafe impl<C: RawCollectorImpl> ::zerogc::CollectorId for CollectorId<C> {
     type System = CollectorRef<C>;
     type RawVecRepr<'gc> = C::RawVecRepr<'gc>;
+    // TODO: What if clients want to customize this?
+    type ArrayRepr<'gc, T: 'gc> = zerogc::array::repr::ThinArrayRepr<'gc, T, Self>;
 
     #[inline]
     fn from_gc_ptr<'a, 'gc, T>(gc: &'a Gc<'gc, T, Self>) -> &'a Self where T: ?Sized + 'gc, 'gc: 'a {
         C::id_for_gc(gc)
     }
 
     #[inline]
-    fn resolve_array_len<'gc, T>(gc: GcArray<'gc, T, Self>) -> usize where T: 'gc {
-        C::resolve_array_len(gc)
-    }
-
-    #[inline]
-    fn resolve_array_id<'a, 'gc, T>(gc: &'a GcArray<'gc, T, Self>) -> &'a Self where T: 'gc, 'gc: 'a {
+    fn resolve_array_id<'a, 'gc, T>(gc: &'a Self::ArrayRepr<'gc, T>) -> &'a Self where T: 'gc, 'gc: 'a {
         C::id_for_array(gc)
     }
 
@@ -327,6 +326,12 @@ unsafe impl<C: RawCollectorImpl> ::zerogc::CollectorId for CollectorId<C> {
         &*(self as *const CollectorId<C> as *const CollectorRef<C>)
     }
 }
+unsafe impl<C: RawCollectorImpl> zerogc::array::repr::ThinArrayGcAccess for CollectorId<C> {
+    #[inline]
+    fn resolve_array_len<'gc, T>(gc: Self::ArrayRepr<'gc, T>) -> usize where T: 'gc {
+        C::resolve_array_len(gc)
+    }
+}
 unsafe impl<'gc, OtherId: zerogc::CollectorId, C: RawCollectorImpl> GcSafe<'gc, OtherId> for CollectorId<C> {}
 unsafe impl<C: RawCollectorImpl> Trace for CollectorId<C> {
     const NEEDS_TRACE: bool = false;

libs/simple/src/lib.rs

@@ -72,6 +72,7 @@ use zerogc_context::collector::{RawSimpleAlloc, RawCollectorImpl};
 use zerogc_context::handle::{GcHandleList, RawHandleImpl};
 use zerogc_context::{CollectionManager as AbstractCollectionManager, RawContext as AbstractRawContext, CollectorContext};
 use zerogc::vec::{GcRawVec};
+use zerogc::array::repr::{GcArrayRepr, ThinArrayRepr};
 use std::cell::Cell;
 use std::ffi::c_void;
 
@@ -142,7 +143,7 @@ pub type CollectorId = ::zerogc_context::CollectorId<RawSimpleCollector>;
 /// A garbage collected pointer, allocated in the "simple" collector
 pub type Gc<'gc, T> = ::zerogc::Gc<'gc, T, CollectorId>;
 /// A garbage collected array, allocated in the "simple" collector
-pub type GcArray<'gc, T> = ::zerogc::vec::GcArray<'gc, T, CollectorId>;
+pub type GcArray<'gc, T> = ::zerogc::array::GcArray<'gc, T, CollectorId>;
 /// A garbage colelcted vector, allocated in the "simple" collector
 pub type GcVec<'gc, T> = ::zerogc::vec::GcVec<'gc, T, SimpleCollectorContext>;
 
@@ -647,10 +648,10 @@ unsafe impl ::zerogc_context::collector::RawCollectorImpl for RawSimpleCollector
     }
 
     #[inline]
-    fn id_for_array<'a, 'gc, T>(gc: &'a GcArray<'gc, T>) -> &'a CollectorId where 'gc: 'a, T: 'gc {
+    fn id_for_array<'a, 'gc, T>(repr: &'a ThinArrayRepr<'gc, T, CollectorId>) -> &'a CollectorId where 'gc: 'a, T: 'gc {
         #[cfg(feature = "multiple-collectors")] {
             unsafe {
-                let header = GcArrayHeader::LAYOUT.from_value_ptr(gc.as_raw_ptr());
+                let header = GcArrayHeader::LAYOUT.from_value_ptr(repr.as_raw_ptr());
                 &*(*header).common_header.mark_data.load_snapshot().collector_id_ptr
             }
         }
@@ -661,7 +662,7 @@ unsafe impl ::zerogc_context::collector::RawCollectorImpl for RawSimpleCollector
     }
 
     #[inline]
-    fn resolve_array_len<'gc, T>(gc: zerogc::GcArray<'gc, T, CollectorId>) -> usize where T: 'gc {
+    fn resolve_array_len<'gc, T>(gc: ThinArrayRepr<'gc, T, CollectorId>) -> usize where T: 'gc {
         unsafe {
             let header = GcArrayHeader::LAYOUT.from_value_ptr(gc.as_raw_ptr());
             (*header).len
@@ -1002,16 +1003,16 @@ unsafe impl GcVisitor for MarkVisitor<'_> {
     }
 
     #[inline]
-    unsafe fn visit_array<'gc, T, Id>(&mut self, array: &mut ::zerogc::vec::GcArray<'gc, T, Id>) -> Result<(), Self::Err>
+    unsafe fn visit_array<'gc, T, Id>(&mut self, array: &mut ::zerogc::array::GcArray<'gc, T, Id>) -> Result<(), Self::Err>
         where T: GcSafe<'gc, Id>, Id: ::zerogc::CollectorId {
         if TypeId::of::<Id>() == TypeId::of::<crate::CollectorId>() {
             /*
              * See comment in 'visit_gc'.
              * Essentially this is a checked cast
              */
             let array = std::mem::transmute::<
-                &mut ::zerogc::vec::GcArray<'gc, T, Id>,
-                &mut ::zerogc::vec::GcArray<'gc, T, crate::CollectorId>
+                &mut ::zerogc::array::GcArray<'gc, T, Id>,
+                &mut ::zerogc::array::GcArray<'gc, T, crate::CollectorId>
             >(array);
             /*
              * Check the collectors match. Otherwise we're mutating

src/array.rs

@@ -0,0 +1,102 @@
+//! Defines the interface to garbage collected arrays.
+use core::ops::Deref;
+use core::ptr::NonNull;
+
+use crate::{CollectorId, GcSafe, GcRebrand};
+use zerogc_derive::unsafe_gc_impl;
+
+use self::repr::GcArrayRepr;
+
+pub mod repr;
+
+/// A garbage collected array.
+///
+/// The length is immutable and cannot change
+/// once it has been allocated.
+///
+/// ## Safety
+/// This is a `#[repr(transparent)]` wrapper around
+/// [GcArrayRepr].
+#[repr(transparent)]
+pub struct GcArray<'gc, T: 'gc, Id: CollectorId> {
+    repr: Id::ArrayRepr<'gc, T>
+}
+impl<'gc, T: GcSafe<'gc, Id>, Id: CollectorId> GcArray<'gc, T, Id> {
+    /// Create an array from the specified raw pointer and length
+    ///
+    /// ## Safety
+    /// Pointer and length must be valid, and point to a garbage collected
+    /// value allocated from the corresponding [CollectorId]
+    #[inline]
+    pub unsafe fn from_raw_ptr(ptr: NonNull<T>, len: usize) -> Self {
+        GcArray { repr: Id::ArrayRepr::<'gc, T>::from_raw_parts(ptr, len) }
+    }
+}
+// Relax T: GcSafe bound
+impl<'gc, T, Id: CollectorId> GcArray<'gc, T, Id> {
+    /// The value of the array as a slice
+    #[inline]
+    pub fn as_slice(self) -> &'gc [T] {
+        self.repr.as_slice()
+    }
+    /// Load a raw pointer to the array's value
+    #[inline]
+    pub fn as_raw_ptr(self) -> *mut T {
+        self.repr.as_raw_ptr()
+    }
+    /// Load the length of the array
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.repr.len()
+    }
+    /// Check if the array is empty
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.repr.is_empty()
+    }
+    /// Resolve the [CollectorId]
+    #[inline]
+    pub fn collector_id(&self) -> &'_ Id {
+        Id::resolve_array_id(&self.repr)
+    }
+    /// Get access to the array's underlying representation. 
+    #[inline]
+    pub fn as_raw_repr(&self) -> &Id::ArrayRepr<'gc, T> {
+        &self.repr
+    }
+}
+impl<'gc, T: GcSafe<'gc, Id>, Id: CollectorId> Deref for GcArray<'gc, T, Id> {
+    type Target = [T];
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.as_slice()
+    }
+}
+impl<'gc, T, Id: CollectorId> Copy for GcArray<'gc, T, Id> {}
+impl<'gc, T, Id: CollectorId> Clone for GcArray<'gc, T, Id> {
+    #[inline]
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+// Need to implement by hand, because [T] is not GcRebrand
+unsafe_gc_impl!(
+    target => GcArray<'gc, T, Id>,
+    params => ['gc, T: GcSafe<'gc, Id>, Id: CollectorId],
+    bounds => {
+        TraceImmutable => never,
+        GcRebrand => { where T: GcRebrand<'new_gc, Id>, <T as GcRebrand<'new_gc, Id>>::Branded: Sized + GcSafe<'new_gc, Id> },
+    },
+    null_trace => never,
+    branded_type => GcArray<'new_gc, <T as GcRebrand<'new_gc, Id>>::Branded, Id>,
+    NEEDS_TRACE => true,
+    NEEDS_DROP => false,
+    trace_mut => |self, visitor| {
+        unsafe { visitor.visit_array(self) }
+    },
+    collector_id => Id,
+    visit_inside_gc => |gc, visitor| {
+        visitor.visit_gc(gc)
+    }
+);

src/array/repr.rs

@@ -0,0 +1,165 @@
+//! Defines the underlying reprsention of a [GcArray] pointer.
+//!
+//!
+//! Two default implementations are also included:
+//! 1. FatArrayRepr - Represents arrays as a fat pointer
+//! 2. ThinArrayRepr - Represents arrays as a thin pointer,
+//!    with the length stored indirectly in the object header.
+use core::marker::PhantomData;
+use core::ptr::NonNull;
+
+
+use crate::{CollectorId, Gc};
+
+
+/// The raw representation of a GcArray pointer.
+///
+///
+/// NOTE: This is only for customizing the *pointer*
+/// representation. The in-memory layout of the array and its
+/// header can be controlled separately from the pointer
+/// (ie. feel free to use a builtin impl even if you have a custom header).
+///
+/// ## Safety
+/// The length and never change (and be valid for
+/// the corresponding allocation).
+///
+/// The underlying 'repr' is responsible
+/// for dropping memory as appropriate.
+pub unsafe trait GcArrayRepr<'gc, T>: Copy {
+    /// The repr's collector
+    type Id: CollectorId;
+    /// Construct an array representation from a combination
+    /// of a pointer and length.
+    ///
+    /// This is the garbage collected equivalent of [std::slice::from_raw_parts]
+    ///
+    /// ## Safety
+    /// The combination of pointer + length must be valid. 
+    unsafe fn from_raw_parts(ptr: NonNull<T>, len: usize) -> Self;
+    /// Get the length of the array
+    fn len(&self) -> usize;
+    /// Check if the array is empty
+    #[inline]
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    /// Load a raw pointer to the array's value
+    fn as_raw_ptr(&self) -> *mut T;
+    /// Get the value of the array as a slice
+    #[inline]
+    fn as_slice(&self) -> &'gc [T] {
+        // SAFETY: Guaranteed by the unsafety of the trait
+        unsafe {
+            std::slice::from_raw_parts(
+                self.as_raw_ptr() as *const T,
+                self.len()
+            )
+        }
+    }
+}
+
+/// Represents an array as a fat pointer.
+///
+/// ## Safety
+/// This type is guarenteed to be compatible with `&[T]`.
+/// Transmuting back and forth is safe.
+#[repr(transparent)]
+pub struct FatArrayRepr<'gc, T: 'gc, Id: CollectorId> {
+    slice: NonNull<[T]>,
+    marker: PhantomData<Gc<'gc, [T], Id>>
+}
+impl<'gc, T, Id: CollectorId> Copy for FatArrayRepr<'gc, T, Id> {}
+impl<'gc, T, Id: CollectorId> Clone for FatArrayRepr<'gc, T, Id> {
+    #[inline]
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+unsafe impl<'gc, T, Id: CollectorId> GcArrayRepr<'gc, T> for FatArrayRepr<'gc, T, Id> {
+    type Id = Id;
+
+    #[inline]
+    unsafe fn from_raw_parts(ptr: NonNull<T>, len: usize) -> Self {
+        FatArrayRepr {
+            slice: NonNull::new_unchecked(
+                core::ptr::slice_from_raw_parts(
+                    ptr.as_ptr() as *const T, len
+                ) as *mut [T]
+            ),
+            marker: PhantomData
+        }
+    }
+
+    #[inline]
+    fn len(&self) -> usize {
+        unsafe { self.slice.as_ref().len() }
+    }
+
+    #[inline]
+    fn as_raw_ptr(&self) -> *mut T {
+        self.slice.as_ptr() as *mut T
+    }
+
+    #[inline]
+    fn as_slice(&self) -> &'gc [T] {
+        unsafe { &*self.slice.as_ptr() }
+    }
+
+}
+
+/// Represents an array as a thin pointer,
+/// storing the length indirectly in the object's header.
+///
+/// ## Safety
+/// This type has the same layout as `&T`,
+/// and can be transmuted back and forth
+/// (assuming the appropriate invariants are met).
+#[repr(transparent)]
+pub struct ThinArrayRepr<'gc, T: 'gc, Id: ThinArrayGcAccess> {
+    elements: NonNull<T>,
+    marker: PhantomData<Gc<'gc, [T], Id>>    
+}
+impl<'gc, T, Id: ThinArrayGcAccess> Copy for ThinArrayRepr<'gc, T, Id> {}
+impl<'gc, T, Id: ThinArrayGcAccess> Clone for ThinArrayRepr<'gc, T, Id> {
+    #[inline]
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+unsafe impl<'gc, T, Id: ThinArrayGcAccess> GcArrayRepr<'gc, T> for ThinArrayRepr<'gc, T, Id> {
+    type Id = Id;
+    #[inline]
+    fn len(&self) -> usize {
+        Id::resolve_array_len(*self)
+    }
+
+    #[inline]
+    unsafe fn from_raw_parts(ptr: NonNull<T>, len: usize) -> Self {
+        let res = ThinArrayRepr { elements: ptr, marker: PhantomData };
+        debug_assert_eq!(res.len(), len);
+        res
+    }
+
+    #[inline]
+    fn as_raw_ptr(&self) -> *mut T {
+        self.elements.as_ptr()
+    }
+}
+
+/// The raw array access used to implement []
+///
+/// This should be considered an implementation detail.
+///
+/// Usage of this type is incredibly niche unless you
+/// plan on implementing your own collector.
+///
+/// ## Safety
+/// The returned length must be correct.
+#[doc(hidden)]
+pub unsafe trait ThinArrayGcAccess: CollectorId {
+    /// Resolve the length of the specified [GcArray]
+    fn resolve_array_len<'gc, T>(repr: ThinArrayRepr<'gc, T, Self>) -> usize
+        where T: 'gc;
+}