add hashbrown feature

Author: tickbh

Diff for: Cargo.lock

@@ -12,6 +12,7 @@ keywords = ["algorithm", "lru", "lfu", "timerwheel", "slab"]
 
 [dependencies]
 lazy_static="1.4.0"
+hashbrown="0.14"
 
 [dev-dependencies]
 rand="0.8.5"
@@ -20,4 +21,7 @@ slab = "0.4.9"
 
 [profile.release]
 opt-level = 3
-debug = true
+debug = true
+
+[features]
+hashbrown=[]

Diff for: Cargo.toml

@@ -1,4 +1,3 @@
-use std::collections::hash_map::RandomState;
 use std::time::Instant;
 use algorithm::{ArcCache, LfuCache, LruCache, LruKCache};
 
@@ -65,10 +64,10 @@ fn build_high_freq_data(num: usize) -> Vec<(usize, usize)> {
 
 fn do_bench(num: usize) {
     let evict = num * 2;
-    let mut lru = LruCache::<usize, usize, RandomState>::new(num);
-    let mut lruk = LruKCache::<usize, usize, RandomState>::new(num);
-    let mut lfu = LfuCache::<usize, usize, RandomState>::new(num);
-    let mut arc = ArcCache::<usize, usize, RandomState>::new(num / 2);
+    let mut lru = LruCache::new(num);
+    let mut lruk = LruKCache::new(num);
+    let mut lfu = LfuCache::new(num);
+    let mut arc = ArcCache::new(num / 2);
     println!("|名字|耗时|命中率|");
     println!("|---|---|---|");
     // let data = build_freq_data(evict);
@@ -81,5 +80,5 @@ fn do_bench(num: usize) {
 }
 
 fn main() {
-    do_bench(1e6 as usize);
+    do_bench(1e5 as usize);
 }

Diff for: examples/bench_lru.rs

@@ -12,12 +12,12 @@
 
 use std::{
     borrow::Borrow,
-    collections::hash_map::RandomState,
     fmt::{self, Debug},
     hash::{BuildHasher, Hash},
     ops::{Index, IndexMut},
 };
 
+use crate::DefaultHasher;
 use crate::{LfuCache, LruCache};
 
 use super::{lfu, lru};
@@ -53,10 +53,10 @@ pub struct ArcCache<K, V, S> {
     cap: usize,
 }
 
-impl<K: Hash + Eq, V> ArcCache<K, V, RandomState> {
+impl<K: Hash + Eq, V> ArcCache<K, V, DefaultHasher> {
     /// 因为存在四个数组, 所以实际的容量为这个的4倍
     pub fn new(cap: usize) -> Self {
-        ArcCache::with_hasher(cap, RandomState::new())
+        ArcCache::with_hasher(cap, DefaultHasher::default())
     }
 }
 
@@ -715,15 +715,15 @@ impl<'a, K: Hash + Eq, V, S: BuildHasher> Iterator for ValuesMut<'a, K, V, S> {
     }
 }
 
-impl<K: Hash + Eq, V> FromIterator<(K, V)> for ArcCache<K, V, RandomState> {
-    fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> ArcCache<K, V, RandomState> {
+impl<K: Hash + Eq, V> FromIterator<(K, V)> for ArcCache<K, V, DefaultHasher> {
+    fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> ArcCache<K, V, DefaultHasher> {
         let mut arc = ArcCache::new(2);
         arc.extend(iter);
         arc
     }
 }
 
-impl<K: Hash + Eq, V> Extend<(K, V)> for ArcCache<K, V, RandomState> {
+impl<K: Hash + Eq, V> Extend<(K, V)> for ArcCache<K, V, DefaultHasher> {
     fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) {
         let iter = iter.into_iter();
         for (k, v) in iter {
@@ -797,8 +797,7 @@ unsafe impl<K: Sync, V: Sync, S: Sync> Sync for ArcCache<K, V, S> {}
 
 #[cfg(test)]
 mod tests {
-    use std::collections::hash_map::RandomState;
-
+    use crate::DefaultHasher;
     use super::ArcCache;
 
     #[test]
@@ -853,13 +852,13 @@ mod tests {
 
     #[test]
     fn test_empty_remove() {
-        let mut m: ArcCache<isize, bool, RandomState> = ArcCache::new(2);
+        let mut m: ArcCache<isize, bool, DefaultHasher> = ArcCache::new(2);
         assert_eq!(m.remove(&0), None);
     }
 
     #[test]
     fn test_empty_iter() {
-        let mut m: ArcCache<isize, bool, RandomState> = ArcCache::new(2);
+        let mut m: ArcCache<isize, bool, DefaultHasher> = ArcCache::new(2);
         assert_eq!(m.iter().next(), None);
         assert_eq!(m.iter_mut().next(), None);
         assert_eq!(m.len(), 0);

Diff for: src/cache/arc.rs

@@ -14,13 +14,13 @@ use std::fmt::Debug;
 use std::ops::{Index, IndexMut};
 use std::{
     borrow::Borrow,
-    collections::{hash_map::RandomState, HashMap, HashSet},
     fmt,
     hash::{BuildHasher, Hash},
     mem,
     ptr::NonNull,
 };
 
+use crate::{HashMap, HashSet, DefaultHasher};
 use lazy_static::lazy_static;
 
 use super::{KeyRef, KeyWrapper};
@@ -128,9 +128,9 @@ pub struct LfuCache<K, V, S> {
     reduce_count: usize,
 }
 
-impl<K: Hash + Eq, V> LfuCache<K, V, RandomState> {
+impl<K: Hash + Eq, V> LfuCache<K, V, DefaultHasher> {
     pub fn new(cap: usize) -> Self {
-        LfuCache::with_hasher(cap, RandomState::new())
+        LfuCache::with_hasher(cap, DefaultHasher::default())
     }
 }
 
@@ -1169,15 +1169,15 @@ impl<'a, K: Hash + Eq, V, S: BuildHasher> Iterator for ValuesMut<'a, K, V, S> {
     }
 }
 
-impl<K: Hash + Eq, V> FromIterator<(K, V)> for LfuCache<K, V, RandomState> {
-    fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> LfuCache<K, V, RandomState> {
+impl<K: Hash + Eq, V> FromIterator<(K, V)> for LfuCache<K, V, DefaultHasher> {
+    fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> LfuCache<K, V, DefaultHasher> {
         let mut lru = LfuCache::new(2);
         lru.extend(iter);
         lru
     }
 }
 
-impl<K: Hash + Eq, V> Extend<(K, V)> for LfuCache<K, V, RandomState> {
+impl<K: Hash + Eq, V> Extend<(K, V)> for LfuCache<K, V, DefaultHasher> {
     fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) {
         let iter = iter.into_iter();
         for (k, v) in iter {
@@ -1251,8 +1251,7 @@ unsafe impl<K: Sync, V: Sync, S: Sync> Sync for LfuCache<K, V, S> {}
 
 #[cfg(test)]
 mod tests {
-    use std::collections::hash_map::RandomState;
-
+    use crate::DefaultHasher;
     use super::LfuCache;
 
     #[test]
@@ -1299,13 +1298,13 @@ mod tests {
 
     #[test]
     fn test_empty_remove() {
-        let mut m: LfuCache<isize, bool, RandomState> = LfuCache::new(2);
+        let mut m: LfuCache<isize, bool, DefaultHasher> = LfuCache::new(2);
         assert_eq!(m.remove(&0), None);
     }
 
     #[test]
     fn test_empty_iter() {
-        let mut m: LfuCache<isize, bool, RandomState> = LfuCache::new(2);
+        let mut m: LfuCache<isize, bool, DefaultHasher> = LfuCache::new(2);
         assert_eq!(m.iter().next(), None);
         assert_eq!(m.iter_mut().next(), None);
         assert_eq!(m.len(), 0);