Add a default feature-flag for "multiple-collectors"

If this is off, than `SimpleCollector` is a global singleton.
Gc pointers don't need to store a reference to their owning collector,
so they should be just a single thin pointer.

Make `Gc` pointer repr(C), since DuckLogic will rely on the assumption
it's represented just like a simple pointer.
Outside of safepoints, that's all it really is ;)

Author: Techcable

libs/simple/Cargo.toml

@@ -24,6 +24,7 @@ serde = { version = "1", optional = true }
 default = [
     "small-object-arenas", # Without this, allocating small objects is slow
     "sync", # Thread-safety by default
+    "multiple-collectors", # By default, allow multiple collectors
 ]
 # Use very fast dedicated arenas for small objects.
 # This makes allocation much faster
@@ -44,6 +45,12 @@ implicit-grey-stack = []
 #
 # This can increase overhead by requiring communication between threads.
 sync = []
+# Allow multiple collectors to exist at once
+# Otherwise, there's a single global collector (useful in VMs)
+#
+# Even if multiple collectors are enabled, pointers from
+# one collector can't be safely mixed with other collectors.
+multiple-collectors = []
 
 [dev-dependencies]
 # Used for examples :)

libs/simple/src/context/mod.rs

@@ -96,7 +96,7 @@ impl SimpleCollectorContext {
     pub(crate) unsafe fn from_collector(collector: &SimpleCollector) -> Self {
         SimpleCollectorContext {
             raw: Box::into_raw(ManuallyDrop::into_inner(
-                RawContext::from_collector(collector.0.clone())
+                RawContext::from_collector(collector.internal_clone())
             )),
             root: true // We are the exclusive owner
         }
@@ -105,14 +105,14 @@ impl SimpleCollectorContext {
     pub(crate) unsafe fn register_root(collector: &SimpleCollector) -> Self {
         SimpleCollectorContext {
             raw: Box::into_raw(ManuallyDrop::into_inner(
-                RawContext::register_new(&collector.0)
+                RawContext::register_new(&collector)
             )),
             root: true, // We are responsible for unregistering
         }
     }
     #[inline]
     pub(crate) fn collector(&self) -> &RawSimpleCollector {
-        unsafe { &(*self.raw).collector }
+        unsafe { &(*self.raw).collector.as_raw() }
     }
     #[inline(always)]
     unsafe fn with_shadow_stack<R, T: Trace>(
@@ -160,18 +160,18 @@ unsafe impl GcContext for SimpleCollectorContext {
     #[inline]
     unsafe fn basic_safepoint<T: Trace>(&mut self, value: &mut &mut T) {
         debug_assert_eq!((*self.raw).state.get(), ContextState::Active);
-        if (*self.raw).collector.should_collect() {
+        if (*self.raw).collector.as_raw().should_collect() {
             self.trigger_basic_safepoint(value);
         }
         debug_assert_eq!((*self.raw).state.get(), ContextState::Active);
     }
 
     unsafe fn freeze(&mut self) {
-        (*self.raw).collector.manager.freeze_context(&*self.raw);
+        (*self.raw).collector.as_raw().manager.freeze_context(&*self.raw);
     }
 
     unsafe fn unfreeze(&mut self) {
-        (*self.raw).collector.manager.unfreeze_context(&*self.raw);
+        (*self.raw).collector.as_raw().manager.unfreeze_context(&*self.raw);
     }
 
     #[inline]

libs/simple/src/context/simple.rs

@@ -8,7 +8,7 @@ use std::cell::{Cell, UnsafeCell, RefCell};
 
 use slog::{Logger, FnValue, trace, o};
 
-use crate::{RawSimpleCollector};
+use crate::{RawSimpleCollector, SimpleCollector};
 use std::mem::ManuallyDrop;
 use std::fmt::{self, Debug, Formatter};
 use crate::context::{ShadowStack, ContextState};
@@ -67,7 +67,7 @@ pub struct RawContext {
     ///
     /// This is still an Arc for easier use alongside the
     /// thread-safe implementation
-    pub(crate) collector: Arc<RawSimpleCollector>,
+    pub(crate) collector: SimpleCollector,
     // NOTE: We are Send, not Sync
     pub(super) shadow_stack: UnsafeCell<ShadowStack>,
     // TODO: Does the collector access this async?
@@ -91,7 +91,7 @@ impl Debug for RawContext {
     }
 }
 impl RawContext {
-    pub(crate) unsafe fn from_collector(collector: Arc<RawSimpleCollector>) -> ManuallyDrop<Box<Self>> {
+    pub(crate) unsafe fn from_collector(collector: SimpleCollector) -> ManuallyDrop<Box<Self>> {
         assert!(
             !collector.manager.has_existing_context
                 .replace(true),

libs/simple/src/context/sync.rs

@@ -1,10 +1,9 @@
-use std::sync::{Arc};
 use std::cell::{Cell, UnsafeCell};
 use std::sync::atomic::{Ordering, AtomicBool};
 
 use slog::{Logger, FnValue, trace, Drain, o};
 
-use crate::{RawSimpleCollector};
+use crate::{RawSimpleCollector, SimpleCollector};
 use crate::utils::ThreadId;
 use std::mem::ManuallyDrop;
 use std::fmt::{Debug, Formatter};
@@ -96,15 +95,15 @@ impl CollectionManager {
          * context's shadow stack, so unfreezing it while in progress
          * could trigger undefined behavior!!!!!
          */
-        context.collector.prevent_collection(|_| {
+        context.collector.as_raw().prevent_collection(|_| {
             assert_eq!(context.state.get(), ContextState::Frozen);
             context.state.set(ContextState::Active);
         })
     }
 }
 
 pub struct RawContext {
-    pub(crate) collector: Arc<RawSimpleCollector>,
+    pub(crate) collector: SimpleCollector,
     original_thread: ThreadId,
     // NOTE: We are Send, not Sync
     pub(super) shadow_stack: UnsafeCell<ShadowStack>,
@@ -129,26 +128,26 @@ impl Debug for RawContext {
     }
 }
 impl RawContext {
-    pub(crate) unsafe fn register_new(collector: &Arc<RawSimpleCollector>) -> ManuallyDrop<Box<Self>> {
-        let original_thread = if collector.logger.is_trace_enabled() {
+    pub(crate) unsafe fn register_new(collector: &SimpleCollector) -> ManuallyDrop<Box<Self>> {
+        let original_thread = if collector.as_raw().logger.is_trace_enabled() {
             ThreadId::current()
         } else {
             ThreadId::Nop
         };
         let mut context = ManuallyDrop::new(Box::new(RawContext {
-            collector: collector.clone(),
+            collector: collector.clone_internal(),
             original_thread: original_thread.clone(),
-            logger: collector.logger.new(o!(
+            logger: collector.as_raw().logger.new(o!(
                 "original_thread" => original_thread.clone()
             )),
             shadow_stack: UnsafeCell::new(ShadowStack {
                 last: std::ptr::null_mut(),
             }),
             state: Cell::new(ContextState::Active)
         }));
-        let old_num_total = collector.add_context(&mut **context);
+        let old_num_total = collector.as_raw().add_context(&mut **context);
         trace!(
-            collector.logger, "Creating new context";
+            collector.as_raw().logger, "Creating new context";
             "ptr" => format_args!("{:p}", &**context),
             "old_num_total" => old_num_total,
             "current_thread" => &original_thread
@@ -171,11 +170,12 @@ impl RawContext {
          * This assumes that parking_lot priorities pending writes
          * over pending reads. The standard library doesn't guarantee this.
          */
-        let mut guard = self.collector.state.write();
+        let collector = self.collector.as_raw();
+        let mut guard = collector.state.write();
         let state = &mut *guard;
         // If there is not a active `PendingCollection` - create one
         if state.pending.is_none() {
-            assert!(!self.collector.manager.collecting.compare_and_swap(
+            assert!(!collector.manager.collecting.compare_and_swap(
                 false, true, Ordering::SeqCst
             ));
             let id = state.next_pending_id();
@@ -236,7 +236,7 @@ impl RawContext {
             "state" => ?pending.state,
             "collector_id" => expected_id
         );
-        self.collector.await_collection(
+        collector.await_collection(
             expected_id, ptr, guard,
             |state, contexts| {
                 let pending = state.pending.as_mut().unwrap();
@@ -247,20 +247,20 @@ impl RawContext {
                 trace!(
                     self.logger, "Beginning simple collection";
                     "current_thread" => FnValue(|_| ThreadId::current()),
-                    "original_size" => self.collector.heap.allocator.allocated_size(),
+                    "original_size" => collector.heap.allocator.allocated_size(),
                     "contexts" => ?contexts,
                     "total_contexts" => pending.total_contexts,
                     "state" => ?pending.state,
                     "collector_id" => pending.id,
                 );
-                self.collector.perform_raw_collection(&contexts);
+                collector.perform_raw_collection(&contexts);
                 assert_eq!(
                     pending.state,
                     PendingState::InProgress
                 );
                 pending.state = PendingState::Finished;
                 // Now acknowledge that we're finished
-                self.collector.acknowledge_finished_collection(
+                collector.acknowledge_finished_collection(
                     &mut state.pending, ptr
                 );
             }