perf: sharded OnceTable

Cargo.toml

@@ -33,6 +33,7 @@ asyncband = { path = "asyncband" }
 
 # Optional runtime dependencies
 hashbrown = { version = "0.17.1", default-features = false }
+scc = "3.8.6"
 
 # Dev dependencies
 async-channel = { version = "2.5.0" }

asyncband/Cargo.toml

@@ -53,7 +53,7 @@ mpsc = []
 mutex = []
 once = ["semaphore"]
 once-cell = ["semaphore"]
-once-map = ["dep:hashbrown", "once-cell"]
+once-map = ["dep:hashbrown", "dep:scc", "once-cell"]
 oneshot = []
 pool = ["semaphore"]
 rwlock = []
@@ -66,6 +66,7 @@ waitgroup = []
 hashbrown = { workspace = true, default-features = false, features = [
   "inline-more",
 ], optional = true }
+scc = { workspace = true, optional = true }
 
 [dev-dependencies]
 tokio = { workspace = true, features = ["full"] }

asyncband/src/internal/mod.rs

@@ -38,12 +38,6 @@ mod arena;
 #[allow(dead_code)]
 pub(crate) mod countdown;
 
-#[cfg(any(feature = "once-map", feature = "singleflight"))]
-// `OnceMap` and `singleflight` use different subsets of `OnceTable`, so single-feature builds
-// leave some operations in the shared implementation unused.
-#[allow(dead_code)]
-pub(crate) mod once_table;
-
 #[cfg(any(feature = "lazy-cell", feature = "once-cell"))]
 // `LazyCell` and `OnceCell` use different subsets of `ValueCell`, so single-feature builds leave
 // some operations in the shared implementation unused.
@@ -91,3 +85,13 @@ pub(crate) mod waitlist;
 // `new`. One constructor is therefore unused in every single-primitive build.
 #[allow(dead_code)]
 pub(crate) mod waitset;
+
+#[cfg(any(feature = "once-map", feature = "singleflight"))]
+pub fn default_shard_count() -> usize {
+    // Tested on a 32-core machine, the optimal shard count for `OnceMap` and `Singleflight` is 256.
+    // So I use 8 as the coefficient, which is 256 / 32.
+    // Need to test on other machines to see if this coefficient is optimal.
+    // Dashmap use 4.
+    (std::thread::available_parallelism().map_or(1, |parallelism| parallelism.get()) * 8)
+        .next_power_of_two()
+}

asyncband/src/internal/mutex.rs

@@ -36,6 +36,13 @@ impl<T> Mutex<T> {
     }
 }
 
+#[cfg(any(feature = "once-map", feature = "singleflight"))]
+/// Alignment uses 60% more memory (64/40) but improves write performance by 25% at 32 threads. (On
+/// Zen 5 CPUs)
+/// Need to test on other architectures.
+#[repr(align(64))]
+pub struct CachePaddedMutex<T>(pub Mutex<T>);
+
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;