Finish defining the interface to object formats

The complexity seems too high. I think I'm going to remove
the 'GcInternalLayout' implementation.

Author: Techcable

Cargo.toml

@@ -27,7 +27,7 @@ default = ["std"]
 # Depend on the standard library (optional)
 #
 # This implements tracing
-std = []
+std = ["alloc"]
 # Depend on `extern crate alloc` in addition to the Rust `core`
 # This is implied by using the standard library (feature="std")
 #

libs/context/src/collector.rs

@@ -12,6 +12,7 @@ use zerogc::{Gc, GcSafe, GcSystem, Trace, GcSimpleAlloc, NullTrace, TraceImmutab
 
 use crate::{CollectorContext};
 use crate::state::{CollectionManager, RawContext};
+use std::ffi::c_void;
 
 /// A specific implementation of a collector
 pub unsafe trait RawCollectorImpl: 'static + Sized {
@@ -21,6 +22,8 @@ pub unsafe trait RawCollectorImpl: 'static + Sized {
     /// a trait object pointer.
     type GcDynPointer: Copy + Debug + 'static;
 
+    unsafe fn dyn_ptr_from_raw(raw: *mut c_void) -> Self::GcDynPointer;
+
     /// A pointer to this collector
     ///
     /// Must be a ZST if the collector is a singleton.
@@ -45,7 +48,7 @@ pub unsafe trait RawCollectorImpl: 'static + Sized {
         where 'gc: 'a, T: GcSafe + ?Sized + 'gc;
 
     /// Convert the specified value into a dyn pointer
-    unsafe fn create_dyn_pointer<T: Trace>(t: *mut T) -> Self::GcDynPointer;
+    unsafe fn create_dyn_pointer<T: GcSafe>(&self, t: *mut T) -> Self::GcDynPointer;
 
     /// Initialize an instance of the collector
     ///

libs/context/src/handle.rs

@@ -11,15 +11,17 @@ use alloc::vec::Vec;
 use zerogc::{Trace, GcSafe, GcErase, GcRebrand, GcVisitor, NullTrace, TraceImmutable, GcHandleSystem, GcBindHandle};
 use crate::{Gc, WeakCollectorRef, CollectorId, CollectorContext, CollectorRef, CollectionManager};
 use crate::collector::RawCollectorImpl;
+use std::ffi::c_void;
+use crate::utils::AtomicCell;
 
 const INITIAL_HANDLE_CAPACITY: usize = 64;
 
 /// A [RawCollectorImpl] that supports handles
 pub unsafe trait RawHandleImpl: RawCollectorImpl {
     /// Type information
-    type TypeInfo: Sized;
+    type TypeInfo: Sized + Copy;
 
-    fn type_info_for_val<T: GcSafe + ?Sized>(val: &T) -> &'_ Self::TypeInfo;
+    fn type_info_for_val<T: GcSafe>(&self, val: &T) -> Self::TypeInfo;
 
     fn handle_list(&self) -> &GcHandleList<Self>;
 }
@@ -232,7 +234,7 @@ impl<C: RawHandleImpl> GcHandleList<C> {
     /// Now that's behind a layer of abstraction,
     /// the unsafety has technically been moved to the caller.
     pub unsafe fn trace<F, E>(&mut self, mut visitor: F) -> Result<(), E>
-        where F: FnMut(*mut (), &C::TypeInfo) -> Result<(), E> {
+        where F: FnMut(C::GcDynPointer, &C::TypeInfo) -> Result<(), E> {
         /*
          * TODO: This fence seems unnecessary since we should
          * already have exclusive access.....
@@ -361,8 +363,7 @@ pub struct GcRawHandle<C: RawHandleImpl> {
     value: AtomicPtr<()>,
     /// I think this should be protected by the other atomic
     /// accesses. Regardless, I'll put it in an AtomicPtr anyways.
-    // TODO: Encapsulate
-    pub(crate) type_info: AtomicPtr<C::TypeInfo>,
+    pub(crate) type_info: AtomicCell<C::TypeInfo>,
     /// The reference count to the handle
     ///
     /// If this is zero the value can be freed
@@ -379,9 +380,13 @@ impl<C: RawHandleImpl> GcRawHandle<C> {
     /// - It is assumed that the appropriate atomic fences (if any)
     ///   have already been applied (TODO: Don't we have exclusive access?)
     unsafe fn trace_inner<F, E>(&self, trace: &mut F) -> Result<(), E>
-        where F: FnMut(*mut (), &C::TypeInfo) -> Result<(), E> {
-        let value = self.value.load(Ordering::Relaxed);
-        if value.is_null() {
+        where F: FnMut(C::GcDynPointer, &C::TypeInfo) -> Result<(), E> {
+        let raw_value = self.value.load(Ordering::Relaxed);
+        assert_eq!(
+            std::mem::size_of::<*mut ()>(),
+            std::mem::size_of::<C::GcDynPointer>(),
+        );
+        if raw_value.is_null() {
             debug_assert_eq!(
                 self.refcnt.load(Ordering::Relaxed),
                 0
@@ -392,8 +397,9 @@ impl<C: RawHandleImpl> GcRawHandle<C> {
             self.refcnt.load(Ordering::Relaxed),
             0
         );
-        let type_info = &*self.type_info.load(Ordering::Relaxed);
-        trace(value, type_info)
+        let value = C::dyn_ptr_from_raw(raw_value as *mut c_void);
+        let type_info = self.type_info.load();
+        trace(value, &type_info)
     }
 }
 pub struct GcHandle<T: GcSafe, C: RawHandleImpl> {
@@ -598,7 +604,7 @@ unsafe impl<T: GcSafe + Sync, C: RawHandleImpl + Sync> Sync for GcHandle<T, C> {
 /// We support handles
 unsafe impl<'gc, 'a, T, C> GcHandleSystem<'gc, 'a, T> for CollectorRef<C>
     where C: RawHandleImpl,
-          T: GcSafe + 'gc + ?Sized,
+          T: GcSafe + 'gc,
           T: GcErase<'a, CollectorId<C>>,
           T::Erased: GcSafe {
     type Handle = GcHandle<T::Erased, C>;
@@ -616,10 +622,7 @@ unsafe impl<'gc, 'a, T, C> GcHandleSystem<'gc, 'a, T> for CollectorRef<C>
              * the handle!!!
              */
             raw.type_info.store(
-                C::type_info_for_val::<T>(gc.value())
-                    as *const C::TypeInfo
-                    as *mut C::TypeInfo,
-                Ordering::Release
+                collector.as_ref().type_info_for_val::<T>(gc.value())
             );
             raw.refcnt.store(1, Ordering::Release);
             let weak_collector = collector.weak_ref();

libs/context/src/lib.rs

@@ -134,7 +134,7 @@ impl<C: RawCollectorImpl> CollectorContext<C> {
     ) -> R {
         let old_link = (*(*self.raw).shadow_stack_ptr()).last;
         let new_link = ShadowStackLink {
-            element: C::create_dyn_pointer(value),
+            element: (*self.raw).collector().create_dyn_pointer(value),
             prev: old_link
         };
         (*(*self.raw).shadow_stack_ptr()).last = &new_link;

libs/simple/src/alloc.rs

@@ -13,8 +13,8 @@ use parking_lot::Mutex;
 #[cfg(not(feature = "sync"))]
 use std::cell::RefCell;
 
-use crate::layout::{GcHeader};
 use zerogc_context::utils::AtomicCell;
+use zerogc::format::{ObjectFormat, OpenAllocObjectFormat};
 
 /// The minimum size of supported memory (in words)
 ///
@@ -26,11 +26,18 @@ pub const MINIMUM_WORDS: usize = 2;
 /// Past this we have to fallback to the global allocator
 pub const MAXIMUM_SMALL_WORDS: usize = 32;
 /// The alignment of elements in the arena
-pub const ARENA_ELEMENT_ALIGN: usize = mem::align_of::<GcHeader>();
+pub const ARENA_ELEMENT_ALIGN: usize = ARENA_HEADER_LAYOUT.align();
+/// The size of headers in the arena
+///
+/// This is the same regardless of the underlying object format
+const ARENA_HEADER_LAYOUT: Layout = Layout::new::<DummyGcHeader>();
+
+use super::DummyGcHeader;
+use crate::{RawSimpleCollector, RawObjectFormat};
 
 #[inline]
 pub const fn small_object_size<T>() -> usize {
-    let header_layout = Layout::new::<GcHeader>();
+    let header_layout = ARENA_HEADER_LAYOUT;
     header_layout.size() + header_layout
         .padding_needed_for(std::mem::align_of::<T>())
         + mem::size_of::<T>()
@@ -114,7 +121,7 @@ pub struct FreeSlot {
 #[repr(C)]
 pub(crate) union MaybeFreeSlot {
     pub free: FreeSlot,
-    pub header: GcHeader,
+    pub header: DummyGcHeader,
 }
 
 impl MaybeFreeSlot {
@@ -192,7 +199,7 @@ impl ArenaState {
         self.current_chunk.store(ptr);
     }
     #[inline]
-    fn alloc(&self, element_size: usize) -> NonNull<GcHeader> {
+    fn alloc(&self, element_size: usize) -> NonNull<DummyGcHeader> {
         unsafe {
             let chunk = &*self.current_chunk().as_ptr();
             match chunk.try_alloc(element_size) {
@@ -204,7 +211,7 @@ impl ArenaState {
 
     #[cold]
     #[inline(never)]
-    fn alloc_fallback(&self, element_size: usize) -> NonNull<GcHeader> {
+    fn alloc_fallback(&self, element_size: usize) -> NonNull<DummyGcHeader> {
         let mut chunks = self.lock_chunks();
         // Now that we hold the lock, check the current chunk again
         unsafe {
@@ -220,7 +227,7 @@ impl ArenaState {
             self.force_current_chunk(NonNull::from(&**chunks.last().unwrap()));
             self.current_chunk().as_ref()
                 .try_alloc(element_size).unwrap()
-                .cast::<GcHeader>()
+                .cast::<DummyGcHeader>()
         }
     }
 }
@@ -242,7 +249,7 @@ impl FreeList {
         self.next.store(next)
     }
     #[inline]
-    fn take_free(&self) -> Option<NonNull<GcHeader>> {
+    fn take_free(&self) -> Option<NonNull<DummyGcHeader>> {
         loop {
             let next_free = match self.next.load() {
                 Some(free) => free,
@@ -264,25 +271,27 @@ impl FreeList {
     }
 }
 
-pub struct SmallArena {
+pub struct SmallArena<Fmt: RawObjectFormat> {
     pub(crate) element_size: usize,
     state: ArenaState,
-    pub(crate) free: FreeList
+    pub(crate) free: FreeList,
+    format: &'static Fmt
 }
-impl SmallArena {
+impl<Fmt: RawObjectFormat> SmallArena<Fmt> {
     #[cold] // Initialization is the slow path
-    fn with_words(num_words: usize) -> SmallArena {
+    fn with_words(format: &'static Fmt, num_words: usize) -> SmallArena<Fmt> {
         assert!(num_words >= MINIMUM_WORDS);
         let element_size = num_words * mem::size_of::<usize>();
         assert!(INITIAL_SIZE >= element_size * 2);
         let chunks = vec![Chunk::alloc(INITIAL_SIZE)];
         SmallArena {
             state: ArenaState::new(chunks),
             element_size, free: Default::default(),
+            format
         }
     }
     #[inline]
-    pub(crate) fn alloc(&self) -> NonNull<GcHeader> {
+    pub(crate) fn alloc(&self) -> NonNull<DummyGcHeader> {
         // Check the free list
         if let Some(free) = self.free.take_free() {
             free
@@ -303,11 +312,11 @@ impl SmallArena {
     }
 }
 macro_rules! arena_match {
-    ($arenas:expr, $target:ident, max = $max:expr; $($size:pat => $num_words:literal @ $idx:expr),*) => {
+    ($format:expr, $arenas:expr, $target:ident, max = $max:expr; $($size:pat => $num_words:literal @ $idx:expr),*) => {
         Some(match $target {
             $($size => $arenas[$idx].get_or_init(|| {
                 assert_eq!(SMALL_ARENA_SIZES[$idx], $num_words);
-                SmallArena::with_words($num_words)
+                SmallArena::with_words($format, $num_words)
             }),)*
             _ => {
                 assert!($target > $max);
@@ -321,35 +330,35 @@ const SMALL_ARENA_SIZES: [usize; NUM_SMALL_ARENAS] =  [
     10, 12, 14, 16,
     20, 24, 28, 32
 ];
-pub struct SmallArenaList {
+pub struct SmallArenaList<Fmt: RawObjectFormat> {
     // NOTE: Internally boxed to avoid bloating main struct
-    arenas: Box<[OnceCell<SmallArena>; NUM_SMALL_ARENAS]>
+    arenas: Box<[OnceCell<SmallArena<Fmt>>; NUM_SMALL_ARENAS]>
 }
-impl SmallArenaList {
+impl<Fmt: RawObjectFormat> SmallArenaList<Fmt> {
     pub fn new() -> Self {
         // NOTE: Why does writing arrays have to be so difficult:?
         unsafe {
             let mut arenas: Box<[
-                MaybeUninit<OnceCell<SmallArena>>;
+                MaybeUninit<OnceCell<SmallArena<Fmt>>>;
                 NUM_SMALL_ARENAS
             ]> = Box::new_uninit().assume_init();
             for i in 0..NUM_SMALL_ARENAS {
                 arenas[i].as_mut_ptr().write(OnceCell::new());
             }
             SmallArenaList {
-                // NOTE: This is done becuase I want to explicitly specifiy types
+                // NOTE: This is done because I want to explicitly specify types
                 arenas: mem::transmute::<
-                    Box<[MaybeUninit<OnceCell<SmallArena>>; NUM_SMALL_ARENAS]>,
-                    Box<[OnceCell<SmallArena>; NUM_SMALL_ARENAS]>
+                    Box<[MaybeUninit<OnceCell<SmallArena<Fmt>>>; NUM_SMALL_ARENAS]>,
+                    Box<[OnceCell<SmallArena<Fmt>>; NUM_SMALL_ARENAS]>
                 >(arenas)
             }
         }
     }
-    pub fn iter(&self) -> impl Iterator<Item=&SmallArena> + '_ {
+    pub fn iter(&self) -> impl Iterator<Item=&SmallArena<Fmt>> + '_ {
         self.arenas.iter().filter_map(OnceCell::get)
     }
     #[inline] // This should be constant folded away (size/align is const)
-    pub fn find<T>(&self) -> Option<&SmallArena> {
+    pub fn find<T>(&self) -> Option<&SmallArena<Fmt>> {
         if std::mem::align_of::<T>() > ARENA_ELEMENT_ALIGN {
             return None
         }
@@ -359,9 +368,9 @@ impl SmallArenaList {
             / word_size;
         self.find_raw(num_words)
     }
-    #[inline(always)] // We want this constant-folded away......
-    fn find_raw(&self, num_words: usize) -> Option<&SmallArena> {
-        arena_match!(
+    #[inline] // We want this constant-folded away......
+    fn find_raw(&self, num_words: usize) -> Option<&SmallArena<Fmt>> {
+        arena_match!(self.format,
             self.arenas, num_words, max = 32;
             0..=2 => 2 @ 0,
             3 => 3 @ 1,