Make map generic over lock type

This is necessary since there is no particular lock implementation that
"makes sense" on `no_std`. This patch changes all types to be generic
over any lock type that implements `lock_api::RawMutex`, and defaults to
`parking_lot::RawMutex` on `std`.

Note that this patch forks the struct definition for `HashMap` into one
for `std` (which has a default for `L`) and one for `no_std` (which does
not). This is fine since any code written _without_ the `std` feature
_will_ compile with the `std` feature enabled (`indexmap` does the same;
the reverse is not true). We _could_ introduce an intermediate private
struct to avoid repeating the definition, but it would require writing
`self.inner` all over the place, which would be sad. This seemed
marginally cleaner.

Also, this diff makes me want implied bounds a lot:
rust-lang/rust#44491

This is essentially a rebase of adb58e0
and f9ad723 on top of the previous
commit + #47.

Author: jonhoo

Cargo.toml

@@ -21,11 +21,15 @@ maintenance = { status = "experimental" }
 
 [features]
 sanitize = ['crossbeam-epoch/sanitize']
-std = ["crossbeam-epoch/std", "num_cpus"]
+std = ["crossbeam-epoch/std", "num_cpus", "parking_lot"]
 default = ["std"]
 
 [dependencies]
-parking_lot = "0.10"
+lock_api = "0.3.3"
+
+[dependencies.parking_lot]
+version = "0.10"
+optional = true
 
 [dependencies.num_cpus]
 version = "1.12.0"

src/iter/iter.rs

@@ -6,12 +6,18 @@ use crossbeam_epoch::Guard;
 ///
 /// See [`HashMap::iter`](crate::HashMap::iter) for details.
 #[derive(Debug)]
-pub struct Iter<'g, K, V> {
-    pub(crate) node_iter: NodeIter<'g, K, V>,
+pub struct Iter<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
+    pub(crate) node_iter: NodeIter<'g, K, V, L>,
     pub(crate) guard: &'g Guard,
 }
 
-impl<'g, K, V> Iterator for Iter<'g, K, V> {
+impl<'g, K, V, L> Iterator for Iter<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
     type Item = (&'g K, &'g V);
     fn next(&mut self) -> Option<Self::Item> {
         let node = self.node_iter.next()?;
@@ -26,11 +32,17 @@ impl<'g, K, V> Iterator for Iter<'g, K, V> {
 ///
 /// See [`HashMap::keys`](crate::HashMap::keys) for details.
 #[derive(Debug)]
-pub struct Keys<'g, K, V> {
-    pub(crate) node_iter: NodeIter<'g, K, V>,
+pub struct Keys<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
+    pub(crate) node_iter: NodeIter<'g, K, V, L>,
 }
 
-impl<'g, K, V> Iterator for Keys<'g, K, V> {
+impl<'g, K, V, L> Iterator for Keys<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
     type Item = &'g K;
     fn next(&mut self) -> Option<Self::Item> {
         let node = self.node_iter.next()?;
@@ -42,12 +54,18 @@ impl<'g, K, V> Iterator for Keys<'g, K, V> {
 ///
 /// See [`HashMap::values`](crate::HashMap::values) for details.
 #[derive(Debug)]
-pub struct Values<'g, K, V> {
-    pub(crate) node_iter: NodeIter<'g, K, V>,
+pub struct Values<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
+    pub(crate) node_iter: NodeIter<'g, K, V, L>,
     pub(crate) guard: &'g Guard,
 }
 
-impl<'g, K, V> Iterator for Values<'g, K, V> {
+impl<'g, K, V, L> Iterator for Values<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
     type Item = &'g V;
     fn next(&mut self) -> Option<Self::Item> {
         let node = self.node_iter.next()?;

src/iter/traverser.rs

@@ -9,15 +9,18 @@ use core::sync::atomic::Ordering;
 use crossbeam_epoch::{Guard, Shared};
 
 #[derive(Debug)]
-pub(crate) struct NodeIter<'g, K, V> {
+pub(crate) struct NodeIter<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
     /// Current table; update if resized
-    table: Option<&'g Table<K, V>>,
+    table: Option<&'g Table<K, V, L>>,
 
-    stack: Option<Box<TableStack<'g, K, V>>>,
-    spare: Option<Box<TableStack<'g, K, V>>>,
+    stack: Option<Box<TableStack<'g, K, V, L>>>,
+    spare: Option<Box<TableStack<'g, K, V, L>>>,
 
     /// The last bin entry iterated over
-    prev: Option<&'g Node<K, V>>,
+    prev: Option<&'g Node<K, V, L>>,
 
     /// Index of bin to use next
     index: usize,
@@ -34,8 +37,11 @@ pub(crate) struct NodeIter<'g, K, V> {
     guard: &'g Guard,
 }
 
-impl<'g, K, V> NodeIter<'g, K, V> {
-    pub(crate) fn new(table: Shared<'g, Table<K, V>>, guard: &'g Guard) -> Self {
+impl<'g, K, V, L> NodeIter<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
+    pub(crate) fn new(table: Shared<'g, Table<K, V, L>>, guard: &'g Guard) -> Self {
         let (table, len) = if table.is_null() {
             (None, 0)
         } else {
@@ -58,7 +64,7 @@ impl<'g, K, V> NodeIter<'g, K, V> {
         }
     }
 
-    fn push_state(&mut self, t: &'g Table<K, V>, i: usize, n: usize) {
+    fn push_state(&mut self, t: &'g Table<K, V, L>, i: usize, n: usize) {
         let mut s = self.spare.take();
         if let Some(ref mut s) = s {
             self.spare = s.next.take();
@@ -114,8 +120,11 @@ impl<'g, K, V> NodeIter<'g, K, V> {
     }
 }
 
-impl<'g, K, V> Iterator for NodeIter<'g, K, V> {
-    type Item = &'g Node<K, V>;
+impl<'g, K, V, L> Iterator for NodeIter<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
+    type Item = &'g Node<K, V, L>;
     fn next(&mut self) -> Option<Self::Item> {
         let mut e = None;
         if let Some(prev) = self.prev {
@@ -182,30 +191,35 @@ impl<'g, K, V> Iterator for NodeIter<'g, K, V> {
 }
 
 #[derive(Debug)]
-struct TableStack<'g, K, V> {
+struct TableStack<'g, K, V, L>
+where
+    L: lock_api::RawMutex,
+{
     length: usize,
     index: usize,
-    table: &'g Table<K, V>,
-    next: Option<Box<TableStack<'g, K, V>>>,
+    table: &'g Table<K, V, L>,
+    next: Option<Box<TableStack<'g, K, V, L>>>,
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::raw::Table;
     use crossbeam_epoch::{self as epoch, Atomic, Owned};
-    use parking_lot::Mutex;
+    use lock_api::Mutex;
+
+    type L = parking_lot::RawMutex;
 
     #[test]
     fn iter_new() {
         let guard = epoch::pin();
-        let iter = NodeIter::<usize, usize>::new(Shared::null(), &guard);
+        let iter = NodeIter::<usize, usize, L>::new(Shared::null(), &guard);
         assert_eq!(iter.count(), 0);
     }
 
     #[test]
     fn iter_empty() {
-        let table = Owned::new(Table::<usize, usize>::new(16));
+        let table = Owned::new(Table::<usize, usize, L>::new(16));
         let guard = epoch::pin();
         let table = table.into_shared(&guard);
         let iter = NodeIter::new(table, &guard);
@@ -224,7 +238,7 @@ mod tests {
             key: 0usize,
             value: Atomic::new(0usize),
             next: Atomic::null(),
-            lock: Mutex::new(()),
+            lock: Mutex::<L, _>::new(()),
         }));
 
         let table = Owned::new(Table::from(bins));
@@ -259,7 +273,7 @@ mod tests {
         for bin in &mut bins[8..] {
             *bin = Atomic::new(BinEntry::Moved(&*deep_table as *const _));
         }
-        let table = Owned::new(Table::<usize, usize>::from(bins));
+        let table = Owned::new(Table::<usize, usize, L>::from(bins));
         let guard = epoch::pin();
         let table = table.into_shared(&guard);
         {