Make the crate no_std + alloc

Cargo.toml

@@ -20,9 +20,17 @@ codecov = { repository = "jonhoo/flurry", branch = "master", service = "github"
 maintenance = { status = "experimental" }
 
 [dependencies]
-crossbeam-epoch = "0.8"
 parking_lot = "0.10"
 num_cpus = "1.12.0"
 
+[dependencies.crossbeam-epoch]
+version = "0.8"
+default-features = false
+features = ["alloc"]
+
 [dev-dependencies]
 rand = "0.7"
+
+[features]
+default = ["std"]
+std = ["crossbeam-epoch/std"]

src/iter/iter.rs

@@ -1,6 +1,6 @@
 use super::NodeIter;
+use core::sync::atomic::Ordering;
 use crossbeam_epoch::Guard;
-use std::sync::atomic::Ordering;
 
 /// An iterator over a map's entries.
 ///
@@ -61,9 +61,9 @@ impl<'g, K, V> Iterator for Values<'g, K, V> {
 #[cfg(test)]
 mod tests {
     use crate::HashMap;
+    use core::iter::FromIterator;
     use crossbeam_epoch as epoch;
     use std::collections::HashSet;
-    use std::iter::FromIterator;
 
     #[test]
     fn iter() {

src/iter/traverser.rs

@@ -1,7 +1,7 @@
 use crate::node::{BinEntry, Node};
 use crate::raw::Table;
+use core::sync::atomic::Ordering;
 use crossbeam_epoch::{Guard, Shared};
-use std::sync::atomic::Ordering;
 
 #[derive(Debug)]
 pub(crate) struct NodeIter<'g, K, V> {

src/lib.rs

@@ -211,5 +211,7 @@ pub use map::HashMap;
 
 /// Types needed to safely access shared data concurrently.
 pub mod epoch {
-    pub use crossbeam_epoch::{pin, Guard};
+    #[cfg(feature = "std")]
+    pub use crossbeam_epoch::pin;
+    pub use crossbeam_epoch::Guard;
 }

src/map.rs

@@ -1,20 +1,19 @@
 use crate::iter::*;
 use crate::node::*;
 use crate::raw::*;
+use core::borrow::Borrow;
+use core::fmt::{self, Debug, Formatter};
+use core::hash::{BuildHasher, Hash, Hasher};
+use core::iter::FromIterator;
+use core::sync::atomic::{AtomicIsize, AtomicUsize, Ordering};
 use crossbeam_epoch::{self as epoch, Atomic, Guard, Owned, Shared};
-use std::borrow::Borrow;
+#[cfg(feature = "std")]
 use std::collections::hash_map::RandomState;
-use std::fmt::{self, Debug, Formatter};
-use std::hash::{BuildHasher, Hash, Hasher};
-use std::iter::FromIterator;
-use std::sync::{
-    atomic::{AtomicIsize, AtomicUsize, Ordering},
-    Once,
-};
+use std::sync::Once;
 
 macro_rules! isize_bits {
     () => {
-        std::mem::size_of::<isize>() * 8
+        core::mem::size_of::<isize>() * 8
     };
 }
 
@@ -85,6 +84,7 @@ pub struct HashMap<K, V, S = RandomState> {
     build_hasher: S,
 }
 
+#[cfg(feature = "std")]
 impl<K, V> Default for HashMap<K, V, RandomState>
 where
     K: Sync + Send + Clone + Hash + Eq,
@@ -95,6 +95,7 @@ where
     }
 }
 
+#[cfg(feature = "std")]
 impl<K, V> HashMap<K, V, RandomState>
 where
     K: Sync + Send + Clone + Hash + Eq,
@@ -311,7 +312,7 @@ where
             let mut sc = self.size_ctl.load(Ordering::SeqCst);
             if sc < 0 {
                 // we lost the initialization race; just spin
-                std::thread::yield_now();
+                core::sync::atomic::spin_loop_hint();
                 continue;
             }
 
@@ -583,7 +584,7 @@ where
     fn add_count(&self, n: isize, resize_hint: Option<usize>, guard: &Guard) {
         // TODO: implement the Java CounterCell business here
 
-        use std::cmp;
+        use core::cmp;
         let mut count = match n.cmp(&0) {
             cmp::Ordering::Greater => {
                 let n = n as usize;
@@ -672,7 +673,7 @@ where
         let ncpu = num_cpus();
 
         let stride = if ncpu > 1 { (n >> 3) / ncpu } else { n };
-        let stride = std::cmp::max(stride as isize, MIN_TRANSFER_STRIDE);
+        let stride = core::cmp::max(stride as isize, MIN_TRANSFER_STRIDE);
 
         if next_table.is_null() {
             // we are initiating a resize
@@ -957,7 +958,7 @@ where
             // TODO: find out if this is neccessary
             let size = size + (size >> 1) + 1;
 
-            std::cmp::min(MAXIMUM_CAPACITY, size.next_power_of_two())
+            core::cmp::min(MAXIMUM_CAPACITY, size.next_power_of_two())
         } as isize;
 
         loop {
@@ -1447,6 +1448,7 @@ where
     }
 }
 
+#[cfg(feature = "std")]
 impl<K, V> FromIterator<(K, V)> for HashMap<K, V, RandomState>
 where
     K: Sync + Send + Clone + Hash + Eq,
@@ -1472,6 +1474,7 @@ where
     }
 }
 
+#[cfg(feature = "std")]
 impl<'a, K, V> FromIterator<(&'a K, &'a V)> for HashMap<K, V, RandomState>
 where
     K: Sync + Send + Copy + Hash + Eq,
@@ -1483,6 +1486,7 @@ where
     }
 }
 
+#[cfg(feature = "std")]
 impl<'a, K, V> FromIterator<&'a (K, V)> for HashMap<K, V, RandomState>
 where
     K: Sync + Send + Copy + Hash + Eq,

src/node.rs

@@ -1,8 +1,8 @@
 use crate::raw::Table;
+use core::borrow::Borrow;
+use core::sync::atomic::Ordering;
 use crossbeam_epoch::{Atomic, Guard, Shared};
 use parking_lot::Mutex;
-use std::borrow::Borrow;
-use std::sync::atomic::Ordering;
 
 /// Entry in a bin.
 ///

src/raw/mod.rs

@@ -1,7 +1,7 @@
 use crate::node::*;
+use core::fmt::Debug;
+use core::sync::atomic::Ordering;
 use crossbeam_epoch::{Atomic, Guard, Owned, Shared};
-use std::fmt::Debug;
-use std::sync::atomic::Ordering;
 
 #[derive(Debug)]
 pub(crate) struct Table<K, V> {
@@ -35,7 +35,10 @@ impl<K, V> Table<K, V> {
         // anything in the map.
         let guard = unsafe { crossbeam_epoch::unprotected() };
 
-        for bin in Vec::from(std::mem::replace(&mut self.bins, vec![].into_boxed_slice())) {
+        for bin in Vec::from(core::mem::replace(
+            &mut self.bins,
+            vec![].into_boxed_slice(),
+        )) {
             if bin.load(Ordering::SeqCst, guard).is_null() {
                 // bin was never used
                 continue;