refactor: re-export BuildHasherDefault<AHasher> as DefaultHasher (#1013)

Author: MrCroxx

foyer-common/src/code.rs

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::hash::{BuildHasher, Hash};
+use std::hash::{BuildHasher, BuildHasherDefault, Hash};
 
 /// Key trait for the in-memory cache.
 pub trait Key: Send + Sync + 'static + Hash + Eq {}
@@ -26,6 +26,11 @@ impl<T: Send + Sync + 'static> Value for T {}
 pub trait HashBuilder: BuildHasher + Send + Sync + 'static {}
 impl<T> HashBuilder for T where T: BuildHasher + Send + Sync + 'static {}
 
+/// The default hasher for foyer.
+///
+/// It is guaranteed that the hash results of the same key are the same across different runs.
+pub type DefaultHasher = BuildHasherDefault<ahash::AHasher>;
+
 /// Code error.
 #[derive(Debug, thiserror::Error)]
 pub enum CodeError {

foyer-memory/src/cache.rs

@@ -12,19 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::{
-    borrow::Cow,
-    fmt::Debug,
-    future::Future,
-    hash::{BuildHasherDefault, Hash},
-    ops::Deref,
-    sync::Arc,
-};
+use std::{borrow::Cow, fmt::Debug, future::Future, hash::Hash, ops::Deref, sync::Arc};
 
-use ahash::AHasher;
 use equivalent::Equivalent;
 use foyer_common::{
-    code::{HashBuilder, Key, Value},
+    code::{DefaultHasher, HashBuilder, Key, Value},
     event::EventListener,
     future::Diversion,
     metrics::Metrics,
@@ -115,26 +107,25 @@ impl Properties for CacheProperties {
     }
 }
 
-pub type FifoCache<K, V, S = BuildHasherDefault<AHasher>, P = CacheProperties> = RawCache<Fifo<K, V, P>, S>;
-pub type FifoCacheEntry<K, V, S = BuildHasherDefault<AHasher>, P = CacheProperties> = RawCacheEntry<Fifo<K, V, P>, S>;
-pub type FifoFetch<K, V, ER, S = BuildHasherDefault<AHasher>, P = CacheProperties> = RawFetch<Fifo<K, V, P>, ER, S>;
+pub type FifoCache<K, V, S = DefaultHasher, P = CacheProperties> = RawCache<Fifo<K, V, P>, S>;
+pub type FifoCacheEntry<K, V, S = DefaultHasher, P = CacheProperties> = RawCacheEntry<Fifo<K, V, P>, S>;
+pub type FifoFetch<K, V, ER, S = DefaultHasher, P = CacheProperties> = RawFetch<Fifo<K, V, P>, ER, S>;
 
-pub type S3FifoCache<K, V, S = BuildHasherDefault<AHasher>, P = CacheProperties> = RawCache<S3Fifo<K, V, P>, S>;
-pub type S3FifoCacheEntry<K, V, S = BuildHasherDefault<AHasher>, P = CacheProperties> =
-    RawCacheEntry<S3Fifo<K, V, P>, S>;
-pub type S3FifoFetch<K, V, ER, S = BuildHasherDefault<AHasher>, P = CacheProperties> = RawFetch<S3Fifo<K, V, P>, ER, S>;
+pub type S3FifoCache<K, V, S = DefaultHasher, P = CacheProperties> = RawCache<S3Fifo<K, V, P>, S>;
+pub type S3FifoCacheEntry<K, V, S = DefaultHasher, P = CacheProperties> = RawCacheEntry<S3Fifo<K, V, P>, S>;
+pub type S3FifoFetch<K, V, ER, S = DefaultHasher, P = CacheProperties> = RawFetch<S3Fifo<K, V, P>, ER, S>;
 
-pub type LruCache<K, V, S = BuildHasherDefault<AHasher>, P = CacheProperties> = RawCache<Lru<K, V, P>, S>;
-pub type LruCacheEntry<K, V, S = BuildHasherDefault<AHasher>, P = CacheProperties> = RawCacheEntry<Lru<K, V, P>, S>;
-pub type LruFetch<K, V, ER, S = BuildHasherDefault<AHasher>, P = CacheProperties> = RawFetch<Lru<K, V, P>, ER, S>;
+pub type LruCache<K, V, S = DefaultHasher, P = CacheProperties> = RawCache<Lru<K, V, P>, S>;
+pub type LruCacheEntry<K, V, S = DefaultHasher, P = CacheProperties> = RawCacheEntry<Lru<K, V, P>, S>;
+pub type LruFetch<K, V, ER, S = DefaultHasher, P = CacheProperties> = RawFetch<Lru<K, V, P>, ER, S>;
 
-pub type LfuCache<K, V, S = BuildHasherDefault<AHasher>, P = CacheProperties> = RawCache<Lfu<K, V, P>, S>;
-pub type LfuCacheEntry<K, V, S = BuildHasherDefault<AHasher>, P = CacheProperties> = RawCacheEntry<Lfu<K, V, P>, S>;
-pub type LfuFetch<K, V, ER, S = BuildHasherDefault<AHasher>, P = CacheProperties> = RawFetch<Lfu<K, V, P>, ER, S>;
+pub type LfuCache<K, V, S = DefaultHasher, P = CacheProperties> = RawCache<Lfu<K, V, P>, S>;
+pub type LfuCacheEntry<K, V, S = DefaultHasher, P = CacheProperties> = RawCacheEntry<Lfu<K, V, P>, S>;
+pub type LfuFetch<K, V, ER, S = DefaultHasher, P = CacheProperties> = RawFetch<Lfu<K, V, P>, ER, S>;
 
 /// A cached entry holder of the in-memory cache.
 #[derive(Debug)]
-pub enum CacheEntry<K, V, S = BuildHasherDefault<AHasher>, P = CacheProperties>
+pub enum CacheEntry<K, V, S = DefaultHasher, P = CacheProperties>
 where
     K: Key,
     V: Value,
@@ -382,7 +373,7 @@ where
     metrics: Option<Arc<Metrics>>,
 }
 
-impl<K, V> CacheBuilder<K, V, BuildHasherDefault<AHasher>>
+impl<K, V> CacheBuilder<K, V, DefaultHasher>
 where
     K: Key,
     V: Value,
@@ -543,7 +534,7 @@ where
 }
 
 /// In-memory cache with plug-and-play algorithms.
-pub enum Cache<K, V, S = BuildHasherDefault<AHasher>, P = CacheProperties>
+pub enum Cache<K, V, S = DefaultHasher, P = CacheProperties>
 where
     K: Key,
     V: Value,
@@ -594,13 +585,13 @@ where
     }
 }
 
-impl<K, V> Cache<K, V, BuildHasherDefault<AHasher>, CacheProperties>
+impl<K, V> Cache<K, V, DefaultHasher, CacheProperties>
 where
     K: Key,
     V: Value,
 {
     /// Create a new in-memory cache builder with capacity.
-    pub fn builder(capacity: usize) -> CacheBuilder<K, V, BuildHasherDefault<AHasher>> {
+    pub fn builder(capacity: usize) -> CacheBuilder<K, V, DefaultHasher> {
         CacheBuilder::new(capacity)
     }
 }
@@ -806,7 +797,7 @@ where
 
 /// A future that is used to get entry value from the remote storage for the in-memory cache.
 #[pin_project(project = FetchProj)]
-pub enum Fetch<K, V, ER, S = BuildHasherDefault<AHasher>, P = CacheProperties>
+pub enum Fetch<K, V, ER, S = DefaultHasher, P = CacheProperties>
 where
     K: Key,
     V: Value,

foyer/Cargo.toml

@@ -16,7 +16,6 @@ features = ["serde", "tracing", "nightly", "deadlock", "strict_assertions"]
 rustdoc-args = ["--cfg", "docsrs"]
 
 [dependencies]
-ahash = { workspace = true }
 anyhow = { workspace = true }
 equivalent = { workspace = true }
 fastrace = { workspace = true, optional = true }

foyer/src/hybrid/builder.rs

@@ -12,13 +12,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::{borrow::Cow, fmt::Debug, hash::BuildHasherDefault, sync::Arc};
+use std::{borrow::Cow, fmt::Debug, sync::Arc};
 
-use ahash::AHasher;
 #[cfg(feature = "tracing")]
 use foyer_common::tracing::TracingOptions;
 use foyer_common::{
-    code::{HashBuilder, StorageKey, StorageValue},
+    code::{DefaultHasher, HashBuilder, StorageKey, StorageValue},
     event::EventListener,
     metrics::Metrics,
 };
@@ -110,7 +109,7 @@ impl<K, V> HybridCacheBuilder<K, V> {
     }
 
     /// Continue to modify the in-memory cache configurations.
-    pub fn memory(self, capacity: usize) -> HybridCacheBuilderPhaseMemory<K, V, BuildHasherDefault<AHasher>>
+    pub fn memory(self, capacity: usize) -> HybridCacheBuilderPhaseMemory<K, V, DefaultHasher>
     where
         K: StorageKey,
         V: StorageValue,

foyer/src/hybrid/cache.rs

@@ -15,22 +15,21 @@
 use std::{
     fmt::Debug,
     future::Future,
-    hash::{BuildHasherDefault, Hash},
+    hash::Hash,
     ops::Deref,
     pin::Pin,
     sync::Arc,
     task::{ready, Context, Poll},
     time::Instant,
 };
 
-use ahash::AHasher;
 use equivalent::Equivalent;
 #[cfg(feature = "tracing")]
 use fastrace::prelude::*;
 #[cfg(feature = "tracing")]
 use foyer_common::tracing::{InRootSpan, TracingConfig, TracingOptions};
 use foyer_common::{
-    code::{HashBuilder, StorageKey, StorageValue},
+    code::{DefaultHasher, HashBuilder, StorageKey, StorageValue},
     future::Diversion,
     metrics::Metrics,
     properties::{Hint, Location, Properties, Source},
@@ -262,7 +261,7 @@ where
 }
 
 /// A cached entry holder of the hybrid cache.
-pub type HybridCacheEntry<K, V, S = BuildHasherDefault<AHasher>> = CacheEntry<K, V, S, HybridCacheProperties>;
+pub type HybridCacheEntry<K, V, S = DefaultHasher> = CacheEntry<K, V, S, HybridCacheProperties>;
 
 #[derive(Debug)]
 pub struct HybridCacheOptions {
@@ -296,7 +295,7 @@ impl Default for HybridCacheOptions {
 /// ```
 ///
 /// So, `storage` must not hold the reference of `memory`.
-pub struct HybridCache<K, V, S = BuildHasherDefault<AHasher>>
+pub struct HybridCache<K, V, S = DefaultHasher>
 where
     K: StorageKey,
     V: StorageValue,
@@ -353,7 +352,7 @@ where
     }
 }
 
-impl<K, V> HybridCache<K, V, BuildHasherDefault<AHasher>>
+impl<K, V> HybridCache<K, V, DefaultHasher>
 where
     K: StorageKey,
     V: StorageValue,
@@ -729,15 +728,15 @@ impl From<oneshot::error::RecvError> for ObtainFetchError {
 
 /// The future generated by [`HybridCache::fetch`].
 #[cfg(feature = "tracing")]
-pub type HybridFetch<K, V, S = BuildHasherDefault<AHasher>> = InRootSpan<HybridFetchInner<K, V, S>>;
+pub type HybridFetch<K, V, S = DefaultHasher> = InRootSpan<HybridFetchInner<K, V, S>>;
 
 /// The future generated by [`HybridCache::fetch`].
 #[cfg(not(feature = "tracing"))]
-pub type HybridFetch<K, V, S = BuildHasherDefault<AHasher>> = HybridFetchInner<K, V, S>;
+pub type HybridFetch<K, V, S = DefaultHasher> = HybridFetchInner<K, V, S>;
 
 /// A future that is used to get entry value from the remote storage for the hybrid cache.
 #[pin_project]
-pub struct HybridFetchInner<K, V, S = BuildHasherDefault<AHasher>>
+pub struct HybridFetchInner<K, V, S = DefaultHasher>
 where
     K: StorageKey,
     V: StorageValue,

foyer/src/hybrid/writer.rs

@@ -14,18 +14,16 @@
 
 use std::{
     fmt::Debug,
-    hash::BuildHasherDefault,
     time::{Duration, Instant},
 };
 
-use ahash::AHasher;
-use foyer_common::code::{HashBuilder, StorageKey, StorageValue};
+use foyer_common::code::{DefaultHasher, HashBuilder, StorageKey, StorageValue};
 use foyer_storage::Pick;
 
 use crate::{HybridCache, HybridCacheEntry, HybridCachePolicy, HybridCacheProperties};
 
 /// Writer for hybrid cache to support more flexible write APIs.
-pub struct HybridCacheWriter<K, V, S = BuildHasherDefault<AHasher>>
+pub struct HybridCacheWriter<K, V, S = DefaultHasher>
 where
     K: StorageKey,
     V: StorageValue,
@@ -62,7 +60,7 @@ where
 }
 
 /// Writer for disk cache of a hybrid cache to support more flexible write APIs.
-pub struct HybridCacheStorageWriter<K, V, S = BuildHasherDefault<AHasher>>
+pub struct HybridCacheStorageWriter<K, V, S = DefaultHasher>
 where
     K: StorageKey,
     V: StorageValue,

foyer/src/prelude.rs

@@ -17,7 +17,7 @@ pub use crate::common::tracing::TracingOptions;
 pub use crate::{
     common::{
         buf::{BufExt, BufMutExt},
-        code::{Code, CodeError, CodeResult, Key, StorageKey, StorageValue, Value},
+        code::{Code, CodeError, CodeResult, DefaultHasher, Key, StorageKey, StorageValue, Value},
         event::{Event, EventListener},
         properties::{Age, Hint, Location, Source},
         utils::{option::OptionExt, range::RangeBoundsExt, scope::Scope},