[simple] Only depend on parking_lot and crossbeam if feature="sync"

The single threaded collector doesn't need these dependencies.
Alsp be more specific by requiring "crossbeam-utils" instead of
all of "crossbeam". The only thing we care about right now is 'AtomicCell'

Author: Techcable

libs/context/Cargo.toml

@@ -12,11 +12,10 @@ edition = "2018"
 zerogc = { path = "../..", version = "0.1.0" }
 once_cell = { version = "1.4.0", optional = true }
 # Concurrency
-# TODO: Make this optional for the single-threaded implementation
-parking_lot = { version = "0.10", features = ["nightly"] }
-crossbeam = { version = "0.7" }
+parking_lot = { version = "0.11", features = ["nightly"], optional = true }
+crossbeam-utils = { version = "0.8.1", optional = true }
 # Logging
-slog = "2.5"
+slog = "2.7"
 
 [features]
 default = [
@@ -42,7 +41,10 @@ implicit-grey-stack = []
 # by creating a seperate context for each.
 #
 # This can increase overhead by requiring communication between threads.
-sync = []
+sync = [
+    "parking_lot",
+    "crossbeam-utils"
+]
 # Allow multiple collectors to exist at once
 # Otherwise, there's a single global collector (useful in VMs)
 #

libs/simple/Cargo.toml

@@ -1,12 +1,20 @@
 #![allow(clippy::vec_box)] // We must Box<Chunk> for a stable address
-use once_cell::sync::OnceCell;
 use std::alloc::Layout;
-use crate::{GcHeader};
 use std::mem;
 use std::ptr::NonNull;
 use std::mem::MaybeUninit;
+
+#[cfg(feature = "sync")]
+use once_cell::sync::OnceCell;
+#[cfg(not(feature = "sync"))]
+use once_cell::unsync::OnceCell;
+#[cfg(feature = "sync")]
 use parking_lot::Mutex;
-use crossbeam::atomic::AtomicCell;
+#[cfg(not(feature = "sync"))]
+use std::cell::RefCell;
+
+use crate::{GcHeader};
+use crate::utils::AtomicCell;
 
 /// The minimum size of supported memory (in words)
 ///
@@ -136,7 +144,13 @@ struct ArenaState {
     /// This is required for thread safety.
     /// One thread could still be seeing an old chunk's location
     /// after it's been moved.
+    #[cfg(feature = "sync")]
     chunks: Mutex<Vec<Box<Chunk>>>,
+    /// List of chunks, not thread-safe
+    ///
+    /// We still box it however, as an extra check of safety.
+    #[cfg(not(feature = "sync"))]
+    chunks: RefCell<Vec<Box<Chunk>>>,
     /// Lockless access to the current chunk
     ///
     /// The pointers wont be invalidated,
@@ -147,16 +161,29 @@ impl ArenaState {
     fn new(chunks: Vec<Box<Chunk>>) -> Self {
         assert!(!chunks.is_empty());
         let current_chunk = NonNull::from(&**chunks.last().unwrap());
+        let chunk_lock;
+        #[cfg(feature = "sync")] {
+            chunk_lock = Mutex::new(chunks);
+        }
+        #[cfg(not(feature = "sync"))] {
+            chunk_lock = RefCell::new(chunks);
+        }
         ArenaState {
-            chunks: Mutex::new(chunks),
+            chunks: chunk_lock,
             current_chunk: AtomicCell::new(current_chunk)
         }
     }
     #[inline]
+    #[cfg(feature = "sync")]
     fn lock_chunks(&self) -> ::parking_lot::MutexGuard<Vec<Box<Chunk>>> {
         self.chunks.lock()
     }
     #[inline]
+    #[cfg(not(feature = "sync"))]
+    fn lock_chunks(&self) -> ::std::cell::RefMut<Vec<Box<Chunk>>> {
+        self.chunks.borrow_mut()
+    }
+    #[inline]
     fn current_chunk(&self) -> NonNull<Chunk> {
         self.current_chunk.load()
     }

libs/simple/src/alloc.rs

@@ -29,47 +29,14 @@ use std::sync::Arc;
 use std::sync::atomic::{AtomicUsize, AtomicBool, Ordering};
 #[cfg(not(feature = "multiple-collectors"))]
 use std::sync::atomic::AtomicPtr;
-#[cfg(not(feature = "sync"))]
-use std::cell::Cell;
-
 
 use slog::{Logger, FnValue, o, debug};
 use crate::context::{RawContext};
-use crate::utils::ThreadId;
+use crate::utils::{ThreadId, AtomicCell};
 
 pub use crate::context::SimpleCollectorContext;
 use handles::GcHandleList;
 
-#[cfg(feature = "sync")]
-type AtomicCell<T> = ::crossbeam::atomic::AtomicCell<T>;
-/// Fallback `AtomicCell` implementation when we actually
-/// don't care about thread safety
-#[cfg(not(feature = "sync"))]
-#[derive(Default)]
-struct AtomicCell<T>(Cell<T>);
-#[cfg(not(feature = "sync"))]
-impl<T: Copy> AtomicCell<T> {
-    const fn new(value: T) -> Self {
-        AtomicCell(Cell::new(value))
-    }
-    fn store(&self, value: T) {
-        self.0.set(value)
-    }
-    fn load(&self) -> T {
-        self.0.get()
-    }
-    fn compare_exchange(&self, expected: T, updated: T) -> Result<T, T>
-        where T: PartialEq {
-        let existing = self.0.get();
-        if existing == expected {
-            self.0.set(updated);
-            Ok(existing)
-        } else {
-            Err(existing)
-        }
-    }
-}
-
 mod handles;
 mod context;
 mod utils;

libs/simple/src/lib.rs

@@ -1,5 +1,36 @@
-use std::fmt::{Debug, Formatter};
-use std::fmt;
+use std::fmt::{self, Debug, Formatter};
+#[cfg(not(feature = "sync"))]
+use std::cell::Cell;
+
+#[cfg(feature = "sync")]
+pub type AtomicCell<T> = ::crossbeam_utils::atomic::AtomicCell<T>;
+/// Fallback `AtomicCell` implementation when we actually
+/// don't care about thread safety
+#[cfg(not(feature = "sync"))]
+#[derive(Default)]
+pub struct AtomicCell<T>(Cell<T>);
+#[cfg(not(feature = "sync"))]
+impl<T: Copy> AtomicCell<T> {
+    pub const fn new(value: T) -> Self {
+        AtomicCell(Cell::new(value))
+    }
+    pub fn store(&self, value: T) {
+        self.0.set(value)
+    }
+    pub fn load(&self) -> T {
+        self.0.get()
+    }
+    pub fn compare_exchange(&self, expected: T, updated: T) -> Result<T, T>
+        where T: PartialEq {
+        let existing = self.0.get();
+        if existing == expected {
+            self.0.set(updated);
+            Ok(existing)
+        } else {
+            Err(existing)
+        }
+    }
+}
 
 #[derive(Clone)]
 pub enum ThreadId {