Remove the 'object format' API

Within `zerogc-simple`, commit to internal ABI stability.
This is nessecarry for JIT compiled code and FFI code.

Author: Techcable

libs/context/src/collector.rs

@@ -12,17 +12,14 @@ use zerogc::{Gc, GcSafe, GcSystem, Trace, GcSimpleAlloc, NullTrace, TraceImmutab
 
 use crate::{CollectorContext};
 use crate::state::{CollectionManager, RawContext};
-use std::ffi::c_void;
-use zerogc::format::{ObjectFormat, GcLayoutInternals};
 
 /// A specific implementation of a collector
-pub unsafe trait RawCollectorImpl: GcLayoutInternals + 'static + Sized {
+pub unsafe trait RawCollectorImpl: 'static + Sized {
     /// A dynamic pointer to a `Trace` root
     ///
     /// The simple collector implements this as
     /// a trait object pointer.
     type DynTracePtr: Copy + Debug + 'static;
-    type Fmt: ObjectFormat<Self>;
 
     /// A pointer to this collector
     ///
@@ -48,7 +45,7 @@ pub unsafe trait RawCollectorImpl: GcLayoutInternals + 'static + Sized {
         where 'gc: 'a, T: GcSafe + ?Sized + 'gc;
 
     /// Convert the specified value into a dyn pointer
-    unsafe fn create_dyn_pointer<T: Trace>(&self, t: *mut T) -> Self::DynTracePtr;
+    unsafe fn as_dyn_trace_pointer<T: Trace>(t: *mut T) -> Self::DynTracePtr;
 
     /// Initialize an instance of the collector
     ///

libs/context/src/handle.rs

@@ -11,18 +11,15 @@ 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;
-use zerogc::format::ObjectFormat;
 
 const INITIAL_HANDLE_CAPACITY: usize = 64;
 
 /// A [RawCollectorImpl] that supports handles
 pub unsafe trait RawHandleImpl: RawCollectorImpl {
     /// Type information
-    type TypeInfo: Sized + Copy;
+    type TypeInfo: Sized;
 
-    fn type_info_for_val<T: GcSafe>(&self, val: &T) -> Self::TypeInfo;
+    fn type_info_of<T: GcSafe>() -> &'static Self::TypeInfo;
 
     fn handle_list(&self) -> &GcHandleList<Self>;
 }
@@ -235,7 +232,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(<C::Fmt as ObjectFormat<C>>::DynObject, &C::TypeInfo) -> Result<(), E> {
+        where F: FnMut(*mut (), &C::TypeInfo) -> Result<(), E> {
         /*
          * TODO: This fence seems unnecessary since we should
          * already have exclusive access.....
@@ -357,14 +354,15 @@ pub struct GcRawHandle<C: RawHandleImpl> {
     /// Refers to the underlying value of this handle.
     ///
     /// If it's null, it's invalid, and is actually
-    /// a [FreedHandle].
+    /// a freed handle
     ///
     /// The underlying value can only be safely accessed
     /// if there isn't a collection in progress
     value: AtomicPtr<()>,
     /// I think this should be protected by the other atomic
     /// accesses. Regardless, I'll put it in an AtomicPtr anyways.
-    pub(crate) type_info: AtomicCell<C::TypeInfo>,
+    // TODO: Encapsulate
+    pub(crate) type_info: AtomicPtr<C::TypeInfo>,
     /// The reference count to the handle
     ///
     /// If this is zero the value can be freed
@@ -381,13 +379,9 @@ 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(<C::Fmt as ObjectFormat<C>>::DynObject, &C::TypeInfo) -> Result<(), E> {
-        let raw_value = self.value.load(Ordering::Relaxed);
-        assert_eq!(
-            std::mem::size_of::<*mut ()>(),
-            std::mem::size_of::<C::DynTracePtr>(),
-        );
-        if raw_value.is_null() {
+        where F: FnMut(*mut (), &C::TypeInfo) -> Result<(), E> {
+        let value = self.value.load(Ordering::Relaxed);
+        if value.is_null() {
             debug_assert_eq!(
                 self.refcnt.load(Ordering::Relaxed),
                 0
@@ -398,9 +392,8 @@ impl<C: RawHandleImpl> GcRawHandle<C> {
             self.refcnt.load(Ordering::Relaxed),
             0
         );
-        let value = C::Fmt::untyped_object_from_raw(raw_value as *mut c_void);
-        let type_info = self.type_info.load();
-        trace(value, &type_info)
+        let type_info = &*self.type_info.load(Ordering::Relaxed);
+        trace(value, type_info)
     }
 }
 pub struct GcHandle<T: GcSafe, C: RawHandleImpl> {
@@ -623,7 +616,10 @@ unsafe impl<'gc, 'a, T, C> GcHandleSystem<'gc, 'a, T> for CollectorRef<C>
              * the handle!!!
              */
             raw.type_info.store(
-                collector.as_ref().type_info_for_val::<T>(gc.value())
+                C::type_info_of::<T>()
+                    as *const C::TypeInfo
+                    as *mut C::TypeInfo,
+                Ordering::Release
             );
             raw.refcnt.store(1, Ordering::Release);
             let weak_collector = collector.weak_ref();

libs/context/src/lib.rs

@@ -4,7 +4,7 @@
     const_fn_trait_bound, // So generics + const fn are unstable, huh?
 )]
 #![cfg_attr(not(feature = "std"), no_std)]
-//! The implementation of [::zerogc::CollectorContext] that is
+//! The implementation of (GcContext)[`::zerogc::GcContext`] that is
 //! shared among both thread-safe and thread-unsafe code.
 
 /*
@@ -134,7 +134,7 @@ impl<C: RawCollectorImpl> CollectorContext<C> {
     ) -> R {
         let old_link = (*(*self.raw).shadow_stack_ptr()).last;
         let new_link = ShadowStackLink {
-            element: (*self.raw).collector().create_dyn_pointer(value),
+            element: C::as_dyn_trace_pointer(value),
             prev: old_link
         };
         (*(*self.raw).shadow_stack_ptr()).last = &new_link;

libs/context/src/state/nosync.rs

@@ -1,4 +1,4 @@
-//! A simpler implementation of [::zerogc::CollectorContext]
+//! A simpler implementation of (GcContext)[`::zerogc::GcContext`]
 //! that doesn't support multiple threads/contexts.
 //!
 //! In exchange, there is no locking :)

libs/context/src/utils.rs

@@ -9,7 +9,7 @@ use core::cell::Cell;
 #[macro_export]
 macro_rules! field_offset {
     ($target:ty, $($field:ident).+) => {
-        (core::ptr::addr_of!((*(std::ptr::null() as *mut $target))$(.$field)*) as usize)
+        unsafe { (core::ptr::addr_of!((*(std::ptr::null_mut::<$target>()))$(.$field)*) as usize) }
     };
 }
 

libs/simple/examples/binary_trees.rs

@@ -69,7 +69,7 @@ fn main() {
 
     let long_lived_tree = bottom_up_tree(&gc, max_depth);
 
-    let (long_lived_tree, ()) = safepoint_recurse!(gc, long_lived_tree, |gc, long_lived_tree| {
+    let (long_lived_tree, ()) = safepoint_recurse!(gc, long_lived_tree, |gc, _long_lived_tree| {
         (min_depth / 2..max_depth / 2 + 1).into_iter().for_each(|half_depth| {
             let depth = half_depth * 2;
             let iterations = 1 << ((max_depth - depth + min_depth) as u32);

libs/simple/src/alloc.rs

@@ -14,7 +14,6 @@ use parking_lot::Mutex;
 use std::cell::RefCell;
 
 use zerogc_context::utils::AtomicCell;
-use zerogc::format::{ObjectFormat, OpenAllocObjectFormat};
 
 /// The minimum size of supported memory (in words)
 ///
@@ -30,22 +29,25 @@ 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>();
+const ARENA_HEADER_LAYOUT: Layout = Layout::new::<GcHeader>();
 
-use super::DummyGcHeader;
-use crate::{RawSimpleCollector, RawObjectFormat};
+use crate::layout::{GcHeader};
 
 #[inline]
-pub const fn small_object_size<T>() -> usize {
+pub const fn small_object_size(layout: Layout) -> usize {
     let header_layout = ARENA_HEADER_LAYOUT;
     header_layout.size() + header_layout
-        .padding_needed_for(std::mem::align_of::<T>())
-        + mem::size_of::<T>()
+        .padding_needed_for(layout.align())
+        + layout.size()
+}
+#[inline]
+pub const fn fits_small_object(layout: Layout) -> bool {
+    small_object_size(layout) <= MAXIMUM_SMALL_WORDS * std::mem::size_of::<usize>()
+        && layout.align() <= ARENA_ELEMENT_ALIGN
 }
 #[inline]
 pub const fn is_small_object<T>() -> bool {
-    small_object_size::<T>() <= MAXIMUM_SMALL_WORDS * 8
-        && mem::align_of::<T>() <= ARENA_ELEMENT_ALIGN
+    fits_small_object(Layout::new::<T>())
 }
 
 pub(crate) struct Chunk {
@@ -121,7 +123,7 @@ pub struct FreeSlot {
 #[repr(C)]
 pub(crate) union MaybeFreeSlot {
     pub free: FreeSlot,
-    pub header: DummyGcHeader,
+    pub header: GcHeader,
 }
 
 impl MaybeFreeSlot {
@@ -199,7 +201,7 @@ impl ArenaState {
         self.current_chunk.store(ptr);
     }
     #[inline]
-    fn alloc(&self, element_size: usize) -> NonNull<DummyGcHeader> {
+    fn alloc(&self, element_size: usize) -> NonNull<GcHeader> {
         unsafe {
             let chunk = &*self.current_chunk().as_ptr();
             match chunk.try_alloc(element_size) {
@@ -211,7 +213,7 @@ impl ArenaState {
 
     #[cold]
     #[inline(never)]
-    fn alloc_fallback(&self, element_size: usize) -> NonNull<DummyGcHeader> {
+    fn alloc_fallback(&self, element_size: usize) -> NonNull<GcHeader> {
         let mut chunks = self.lock_chunks();
         // Now that we hold the lock, check the current chunk again
         unsafe {
@@ -227,7 +229,7 @@ impl ArenaState {
             self.force_current_chunk(NonNull::from(&**chunks.last().unwrap()));
             self.current_chunk().as_ref()
                 .try_alloc(element_size).unwrap()
-                .cast::<DummyGcHeader>()
+                .cast::<GcHeader>()
         }
     }
 }
@@ -249,7 +251,7 @@ impl FreeList {
         self.next.store(next)
     }
     #[inline]
-    fn take_free(&self) -> Option<NonNull<DummyGcHeader>> {
+    fn take_free(&self) -> Option<NonNull<GcHeader>> {
         loop {
             let next_free = match self.next.load() {
                 Some(free) => free,
@@ -271,27 +273,25 @@ impl FreeList {
     }
 }
 
-pub struct SmallArena<Fmt: RawObjectFormat> {
+pub struct SmallArena {
     pub(crate) element_size: usize,
     state: ArenaState,
-    pub(crate) free: FreeList,
-    format: &'static Fmt
+    pub(crate) free: FreeList
 }
-impl<Fmt: RawObjectFormat> SmallArena<Fmt> {
+impl SmallArena {
     #[cold] // Initialization is the slow path
-    fn with_words(format: &'static Fmt, num_words: usize) -> SmallArena<Fmt> {
+    fn with_words(num_words: usize) -> SmallArena {
         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<DummyGcHeader> {
+    pub(crate) fn alloc(&self) -> NonNull<GcHeader> {
         // Check the free list
         if let Some(free) = self.free.take_free() {
             free
@@ -312,11 +312,11 @@ impl<Fmt: RawObjectFormat> SmallArena<Fmt> {
     }
 }
 macro_rules! arena_match {
-    ($format:expr, $arenas:expr, $target:ident, max = $max:expr; $($size:pat => $num_words:literal @ $idx: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($format, $num_words)
+                SmallArena::with_words($num_words)
             }),)*
             _ => {
                 assert!($target > $max);
@@ -330,16 +330,16 @@ const SMALL_ARENA_SIZES: [usize; NUM_SMALL_ARENAS] =  [
     10, 12, 14, 16,
     20, 24, 28, 32
 ];
-pub struct SmallArenaList<Fmt: RawObjectFormat> {
+pub struct SmallArenaList {
     // NOTE: Internally boxed to avoid bloating main struct
-    arenas: Box<[OnceCell<SmallArena<Fmt>>; NUM_SMALL_ARENAS]>
+    arenas: Box<[OnceCell<SmallArena>; NUM_SMALL_ARENAS]>
 }
-impl<Fmt: RawObjectFormat> SmallArenaList<Fmt> {
+impl SmallArenaList {
     pub fn new() -> Self {
         // NOTE: Why does writing arrays have to be so difficult:?
         unsafe {
             let mut arenas: Box<[
-                MaybeUninit<OnceCell<SmallArena<Fmt>>>;
+                MaybeUninit<OnceCell<SmallArena>>;
                 NUM_SMALL_ARENAS
             ]> = Box::new_uninit().assume_init();
             for i in 0..NUM_SMALL_ARENAS {
@@ -348,29 +348,32 @@ impl<Fmt: RawObjectFormat> SmallArenaList<Fmt> {
             SmallArenaList {
                 // NOTE: This is done because I want to explicitly specify types
                 arenas: mem::transmute::<
-                    Box<[MaybeUninit<OnceCell<SmallArena<Fmt>>>; NUM_SMALL_ARENAS]>,
-                    Box<[OnceCell<SmallArena<Fmt>>; NUM_SMALL_ARENAS]>
+                    Box<[MaybeUninit<OnceCell<SmallArena>>; NUM_SMALL_ARENAS]>,
+                    Box<[OnceCell<SmallArena>; NUM_SMALL_ARENAS]>
                 >(arenas)
             }
         }
     }
-    pub fn iter(&self) -> impl Iterator<Item=&SmallArena<Fmt>> + '_ {
+    pub fn iter(&self) -> impl Iterator<Item=&SmallArena> + '_ {
         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<Fmt>> {
+    pub fn find<T>(&self) -> Option<&SmallArena> {
         if std::mem::align_of::<T>() > ARENA_ELEMENT_ALIGN {
             return None
         }
+        if !is_small_object::<T>() {
+            return None
+        }
         // Divide round up
         let word_size = mem::size_of::<usize>();
-        let num_words = (small_object_size::<T>() + (word_size - 1))
+        let num_words = (small_object_size(Layout::new::<T>()) + (word_size - 1))
             / word_size;
         self.find_raw(num_words)
     }
     #[inline] // We want this constant-folded away......
-    fn find_raw(&self, num_words: usize) -> Option<&SmallArena<Fmt>> {
-        arena_match!(self.format,
+    fn find_raw(&self, num_words: usize) -> Option<&SmallArena> {
+        arena_match!(
             self.arenas, num_words, max = 32;
             0..=2 => 2 @ 0,
             3 => 3 @ 1,