[simple] Move collector ids in the object header

When using multiple collectors, we need to use a `SimpleCollectorId`
to disambiguate beteween them. Before this change, we stored this
inline in the GC pointer, taking up 128 bits of space.
Now, we store it indirectly in the object header. This should
end up saving significant space...

Author: Techcable

libs/simple/src/gc.rs

@@ -17,7 +17,6 @@ use super::CollectorId as SimpleCollectorId;
 #[repr(C)]
 pub struct Gc<'gc, T: GcSafe + 'gc> {
     ptr: NonNull<T>,
-    id: SimpleCollectorId,
     marker: PhantomData<&'gc T>
 }
 impl<'gc, T: GcSafe + 'gc> Gc<'gc, T> {
@@ -29,16 +28,27 @@ impl<'gc, T: GcSafe + 'gc> Gc<'gc, T> {
     pub fn value(&self) -> &'gc T {
        unsafe { &*(&self.ptr as *const NonNull<T> as *const &T) }
     }
+    #[inline]
+    unsafe fn header(&self) -> *mut super::GcHeader {
+        super::GcHeader::from_value_ptr(
+            self.value() as *const T as *mut T,
+            <T as super::StaticGcType>::STATIC_TYPE
+        )
+    }
 }
 unsafe impl<'gc, T: GcSafe + 'gc> GcRef<'gc, T> for Gc<'gc, T> {
     type Id = SimpleCollectorId;
-    #[inline(always)]
+    #[inline]
     fn collector_id(&self) -> Self::Id {
-        self.id
+        unsafe {
+            (*self.header()).collector_id
+        }
     }
-    #[inline(always)]
+    #[inline]
     unsafe fn from_raw(id: SimpleCollectorId, ptr: NonNull<T>) -> Self {
-        Gc { ptr, id, marker: PhantomData }
+        let res = Gc { ptr, marker: PhantomData };
+        debug_assert_eq!(res.collector_id(), id);
+        res
     }
     #[inline(always)]
     fn value(&self) -> &'gc T {
@@ -51,7 +61,7 @@ unsafe impl<'gc, T: GcSafe + 'gc> GcRef<'gc, T> for Gc<'gc, T> {
     #[inline(always)]
     fn system(&self) -> &'_ <Self::Id as CollectorId>::System {
         // This assumption is safe - see the docs
-        unsafe { self.id.assume_valid_system() }
+        unsafe { (*self.header()).collector_id.assume_valid_system() }
     }
 }
 unsafe impl<'gc, O, V> ::zerogc::GcDirectBarrier<'gc, Gc<'gc, O>> for Gc<'gc, V>

libs/simple/src/lib.rs

@@ -276,25 +276,27 @@ impl SimpleAlloc {
         if let Some(arena) = self.small_arenas.find::<T>() {
             let header = arena.alloc();
             unsafe {
+                let collector_id = match self.collector_id {
+                    Some(collector) => collector,
+                    None => {
+                        #[cfg(debug_assertions)] {
+                            unreachable!("Invalid collector id")
+                        }
+                        #[cfg(not(debug_assertions))] {
+                            std::hint::unreachable_unchecked()
+                        }
+                    }
+                };
                 header.as_ptr().write(GcHeader::new(
                     T::STATIC_TYPE,
-                    MarkState::White.to_raw(self.mark_inverted())
+                    MarkState::White.to_raw(self.mark_inverted()),
+                    collector_id
                 ));
                 let value_ptr = header.as_ref().value().cast::<T>();
                 value_ptr.write(value);
                 self.add_allocated_size(small_object_size::<T>());
                 Gc::from_raw(
-                    match self.collector_id {
-                        Some(collector) => collector,
-                        None => {
-                            #[cfg(debug_assertions)] {
-                                unreachable!("Invalid collector id")
-                            }
-                            #[cfg(not(debug_assertions))] {
-                                std::hint::unreachable_unchecked()
-                            }
-                        }
-                    },
+                    collector_id,
                     NonNull::new_unchecked(value_ptr),
                 )
             }
@@ -306,7 +308,8 @@ impl SimpleAlloc {
         let mut object = Box::new(BigGcObject {
             header: GcHeader::new(
                 T::STATIC_TYPE,
-                MarkState::White.to_raw(self.mark_inverted())
+                MarkState::White.to_raw(self.mark_inverted()),
+                self.collector_id.unwrap()
             ),
             static_value: ManuallyDrop::new(value),
             prev: BigObjectLink::new(self.big_object_link.item()),
@@ -810,11 +813,12 @@ struct GcHeader {
      * Do we really need to use atomic stores?
      */
     raw_state: AtomicCell<RawMarkState>,
+    collector_id: CollectorId
 }
 impl GcHeader {
     #[inline]
-    pub fn new(type_info: &'static GcType, raw_state: RawMarkState) -> Self {
-        GcHeader { type_info, raw_state: AtomicCell::new(raw_state) }
+    pub fn new(type_info: &'static GcType, raw_state: RawMarkState, collector_id: CollectorId) -> Self {
+        GcHeader { type_info, raw_state: AtomicCell::new(raw_state), collector_id }
     }
     #[inline]
     pub fn value(&self) -> *mut c_void {