fix: in microbench, hash LRU caches with fixed seed

pgdog/Cargo.toml

@@ -15,6 +15,7 @@ fips = ["tokio-rustls/fips"]
 bench = []
 
 [dependencies]
+foldhash = { version = "0.2", default-features = false }
 bon.workspace = true
 pin-project = "1"
 tokio.workspace = true

pgdog/src/auth/token_cache.rs

@@ -21,8 +21,8 @@ use tokio::sync::OnceCell;
 use tracing::error;
 
 use super::Error;
-use crate::tasks;
 use crate::{backend::pool::Connection, config::config};
+use crate::{tasks, util::LruHasher};
 
 /// Client token cache.
 ///
@@ -101,14 +101,16 @@ struct Stats {
 #[derive(Clone, Debug)]
 pub(crate) struct AuthTokenCache {
     // Lookups use peek to preserve FIFO eviction order.
-    inner: Arc<Mutex<LruCache<Key, Arc<Entry>>>>,
+    inner: Arc<Mutex<LruCache<Key, Arc<Entry>, LruHasher>>>,
     stats: Arc<Stats>,
 }
 
 impl Default for AuthTokenCache {
     fn default() -> Self {
         Self {
-            inner: Arc::new(Mutex::new(LruCache::unbounded())),
+            inner: Arc::new(Mutex::new(LruCache::unbounded_with_hasher(
+                Default::default(),
+            ))),
             stats: Arc::new(Stats::default()),
         }
     }

pgdog/src/backend/prepared_statements.rs

@@ -13,6 +13,7 @@ use crate::{
         messages::{ParameterDescription, RowDescription, parse::Parse},
     },
     state::State,
+    util::LruHasher,
 };
 use crate::{net::ErrorResponse, util::time::deadline};
 use parking_lot::RwLock;
@@ -97,7 +98,7 @@ pub(super) enum HandleResult {
 #[derive(Debug)]
 pub(crate) struct PreparedStatements {
     global_cache: Arc<RwLock<GlobalCache>>,
-    local_cache: LruCache<String, LocalStatement>,
+    local_cache: LruCache<String, LocalStatement, LruHasher>,
     state: ProtocolState,
     // Prepared statements being prepared now on the connection.
     parses: VecDeque<String>,
@@ -123,7 +124,7 @@ impl PreparedStatements {
     pub(crate) fn new(oids: Arc<Oids>) -> Self {
         Self {
             global_cache: frontend::PreparedStatements::global(),
-            local_cache: LruCache::unbounded(),
+            local_cache: LruCache::unbounded_with_hasher(Default::default()),
             state: ProtocolState::default(),
             parses: VecDeque::new(),
             parameter_describes: VecDeque::new(),

pgdog/src/frontend/router/parser/cache/cache_impl.rs

@@ -48,7 +48,7 @@ impl Stats {
 #[derive(Debug)]
 pub(super) struct Inner {
     /// Least-recently-used cache.
-    queries: LruCache<Arc<str>, Arc<Ast>>,
+    queries: LruCache<Arc<str>, Arc<Ast>, crate::util::LruHasher>,
     /// Cache global stats.
     pub(super) stats: Stats,
     /// Cache hits.
@@ -96,7 +96,7 @@ impl Cache {
     fn new() -> Self {
         Self {
             inner: RwLock::new(Inner {
-                queries: LruCache::unbounded(),
+                queries: LruCache::unbounded_with_hasher(Default::default()),
                 stats: Stats::default(),
                 hits: AtomicUsize::default(),
             }),
@@ -344,7 +344,7 @@ mod test {
     #[test]
     fn test_used_statement_survives_eviction() {
         let mut inner = Inner {
-            queries: LruCache::new(2.try_into().unwrap()),
+            queries: LruCache::with_hasher(2.try_into().unwrap(), Default::default()),
             stats: Stats::default(),
             hits: AtomicUsize::default(),
         };

pgdog/src/stats/memory.rs

@@ -72,7 +72,9 @@ impl<V: MemoryUsage> MemoryUsage for HashSet<V> {
     }
 }
 
-impl<K: MemoryUsage + Hash + Eq, V: MemoryUsage + Eq> MemoryUsage for LruCache<K, V> {
+impl<K: MemoryUsage + Hash + Eq, V: MemoryUsage + Eq, S: std::hash::BuildHasher> MemoryUsage
+    for LruCache<K, V, S>
+{
     fn memory_usage(&self) -> usize {
         self.iter()
             .map(|(k, v)| k.memory_usage() + v.memory_usage())

pgdog/src/util.rs

@@ -340,3 +340,8 @@ mod test {
         assert_eq!(sanitize_log_sample("a\nb\nc", 3), "a b");
     }
 }
+
+#[cfg(not(feature = "bench"))]
+pub(crate) type LruHasher = lru::DefaultHasher;
+#[cfg(feature = "bench")]
+pub(crate) type LruHasher = foldhash::fast::FixedState;