deps: replace lru with schnellru (#1217)

* deps: replace lru with schnellru

* bring the peace to the galaxy

Cargo.lock

@@ -3332,7 +3332,6 @@ dependencies = [
  "cumulus-primitives-parachain-inherent",
  "cumulus-relay-chain-interface",
  "futures",
- "lru 0.10.1",
  "parity-scale-codec",
  "polkadot-node-primitives",
  "polkadot-node-subsystem",
@@ -3344,6 +3343,7 @@ dependencies = [
  "sc-consensus-babe",
  "sc-consensus-slots",
  "sc-telemetry",
+ "schnellru",
  "sp-api",
  "sp-application-crypto",
  "sp-block-builder",
@@ -3822,7 +3822,6 @@ dependencies = [
  "cumulus-relay-chain-interface",
  "cumulus-relay-chain-rpc-interface",
  "futures",
- "lru 0.11.0",
  "polkadot-availability-recovery",
  "polkadot-collator-protocol",
  "polkadot-core-primitives",
@@ -3839,6 +3838,7 @@ dependencies = [
  "sc-service",
  "sc-tracing",
  "sc-utils",
+ "schnellru",
  "sp-api",
  "sp-consensus",
  "sp-consensus-babe",
@@ -3857,7 +3857,6 @@ dependencies = [
  "futures",
  "futures-timer",
  "jsonrpsee",
- "lru 0.11.0",
  "parity-scale-codec",
  "pin-project",
  "polkadot-overseer",
@@ -3865,6 +3864,7 @@ dependencies = [
  "sc-client-api",
  "sc-rpc-api",
  "sc-service",
+ "schnellru",
  "serde",
  "serde_json",
  "smoldot",
@@ -7765,9 +7765,6 @@ name = "lru"
 version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eedb2bdbad7e0634f83989bf596f497b070130daaa398ab22d84c39e266deec5"
-dependencies = [
- "hashbrown 0.14.0",
-]
 
 [[package]]
 name = "lru-cache"
@@ -11696,7 +11693,6 @@ dependencies = [
  "fatality",
  "futures",
  "futures-timer",
- "lru 0.11.0",
  "parity-scale-codec",
  "polkadot-erasure-coding",
  "polkadot-node-network-protocol",
@@ -11708,6 +11704,7 @@ dependencies = [
  "polkadot-primitives-test-helpers",
  "rand 0.8.5",
  "sc-network",
+ "schnellru",
  "sp-core",
  "sp-keyring",
  "sp-keystore",
@@ -11726,7 +11723,6 @@ dependencies = [
  "futures",
  "futures-timer",
  "log",
- "lru 0.11.0",
  "parity-scale-codec",
  "polkadot-erasure-coding",
  "polkadot-node-network-protocol",
@@ -11738,6 +11734,7 @@ dependencies = [
  "polkadot-primitives-test-helpers",
  "rand 0.8.5",
  "sc-network",
+ "schnellru",
  "sp-application-crypto",
  "sp-core",
  "sp-keyring",
@@ -11827,7 +11824,6 @@ dependencies = [
  "futures-timer",
  "indexmap 1.9.3",
  "lazy_static",
- "lru 0.11.0",
  "parity-scale-codec",
  "polkadot-erasure-coding",
  "polkadot-node-network-protocol",
@@ -11839,6 +11835,7 @@ dependencies = [
  "polkadot-primitives-test-helpers",
  "sc-keystore",
  "sc-network",
+ "schnellru",
  "sp-application-crypto",
  "sp-keyring",
  "sp-keystore",
@@ -11951,7 +11948,6 @@ dependencies = [
  "futures-timer",
  "kvdb",
  "kvdb-memorydb",
- "lru 0.11.0",
  "merlin 2.0.1",
  "parity-scale-codec",
  "parking_lot 0.12.1",
@@ -11965,6 +11961,7 @@ dependencies = [
  "polkadot-primitives-test-helpers",
  "rand_core 0.5.1",
  "sc-keystore",
+ "schnellru",
  "schnorrkel 0.9.1",
  "sp-application-crypto",
  "sp-consensus",
@@ -12125,7 +12122,6 @@ dependencies = [
  "futures-timer",
  "kvdb",
  "kvdb-memorydb",
- "lru 0.11.0",
  "parity-scale-codec",
  "polkadot-node-primitives",
  "polkadot-node-subsystem",
@@ -12134,6 +12130,7 @@ dependencies = [
  "polkadot-primitives",
  "polkadot-primitives-test-helpers",
  "sc-keystore",
+ "schnellru",
  "sp-application-crypto",
  "sp-core",
  "sp-keyring",
@@ -12333,7 +12330,6 @@ version = "1.0.0"
 dependencies = [
  "async-trait",
  "futures",
- "lru 0.11.0",
  "polkadot-node-metrics",
  "polkadot-node-primitives",
  "polkadot-node-subsystem",
@@ -12341,6 +12337,7 @@ dependencies = [
  "polkadot-node-subsystem-types",
  "polkadot-primitives",
  "polkadot-primitives-test-helpers",
+ "schnellru",
  "sp-api",
  "sp-consensus-babe",
  "sp-core",
@@ -12504,7 +12501,6 @@ dependencies = [
  "kvdb-shared-tests",
  "lazy_static",
  "log",
- "lru 0.11.0",
  "parity-db",
  "parity-scale-codec",
  "parking_lot 0.11.2",
@@ -12520,6 +12516,7 @@ dependencies = [
  "polkadot-primitives-test-helpers",
  "prioritized-metered-channel",
  "rand 0.8.5",
+ "schnellru",
  "sp-application-crypto",
  "sp-core",
  "sp-keystore",
@@ -12537,7 +12534,6 @@ dependencies = [
  "femme",
  "futures",
  "futures-timer",
- "lru 0.11.0",
  "orchestra",
  "parking_lot 0.12.1",
  "polkadot-node-metrics",
@@ -12548,6 +12544,7 @@ dependencies = [
  "polkadot-primitives-test-helpers",
  "prioritized-metered-channel",
  "sc-client-api",
+ "schnellru",
  "sp-api",
  "sp-core",
  "tikv-jemalloc-ctl",
@@ -12992,7 +12989,6 @@ dependencies = [
  "kvdb",
  "kvdb-rocksdb",
  "log",
- "lru 0.11.0",
  "mmr-gadget",
  "pallet-babe",
  "pallet-im-online",
@@ -13066,6 +13062,7 @@ dependencies = [
  "sc-telemetry",
  "sc-transaction-pool",
  "sc-transaction-pool-api",
+ "schnellru",
  "serde",
  "serde_json",
  "serial_test",

cumulus/client/consensus/aura/Cargo.toml

@@ -10,7 +10,7 @@ async-trait = "0.1.73"
 codec = { package = "parity-scale-codec", version = "3.0.0", features = [ "derive" ] }
 futures = "0.3.28"
 tracing = "0.1.37"
-lru = "0.10.0"
+schnellru = "0.2.1"
 
 # Substrate
 sc-client-api = { path = "../../../../substrate/client/api" }

cumulus/client/consensus/aura/src/equivocation_import_queue.rs

@@ -21,7 +21,7 @@
 /// should be thrown out and which ones should be kept.
 use codec::Codec;
 use cumulus_client_consensus_common::ParachainBlockImportMarker;
-use lru::LruCache;
+use schnellru::{ByLength, LruMap};
 
 use sc_consensus::{
 	import_queue::{BasicQueue, Verifier as VerifierT},
@@ -36,27 +36,28 @@ use sp_consensus_aura::{AuraApi, Slot, SlotDuration};
 use sp_core::crypto::Pair;
 use sp_inherents::{CreateInherentDataProviders, InherentDataProvider};
 use sp_runtime::traits::{Block as BlockT, Header as HeaderT};
-use std::{fmt::Debug, num::NonZeroUsize, sync::Arc};
+use std::{fmt::Debug, sync::Arc};
 
-const LRU_WINDOW: usize = 256;
+const LRU_WINDOW: u32 = 256;
 const EQUIVOCATION_LIMIT: usize = 16;
 
 struct NaiveEquivocationDefender {
-	cache: LruCache<u64, usize>,
+	cache: LruMap<u64, usize>,
 }
 
 impl Default for NaiveEquivocationDefender {
 	fn default() -> Self {
-		NaiveEquivocationDefender {
+		NaiveEquivocationDefender { cache: LruMap::new(ByLength::new(LRU_WINDOW)) }
-			cache: LruCache::new(NonZeroUsize::new(LRU_WINDOW).expect("window > 0; qed")),
-		}
 	}
 }
 
 impl NaiveEquivocationDefender {
 	// return `true` if equivocation is beyond the limit.
 	fn insert_and_check(&mut self, slot: Slot) -> bool {
-		let val = self.cache.get_or_insert_mut(*slot, || 0);
+		let val = self
+			.cache
+			.get_or_insert(*slot, || 0)
+			.expect("insertion with ByLength limiter always succeeds; qed");
 		if *val == EQUIVOCATION_LIMIT {
 			true
 		} else {

cumulus/client/relay-chain-minimal-node/Cargo.toml

@@ -36,7 +36,7 @@ cumulus-relay-chain-rpc-interface = { path = "../relay-chain-rpc-interface" }
 cumulus-primitives-core = { path = "../../primitives/core" }
 
 array-bytes = "6.1"
-lru = "0.11.0"
+schnellru = "0.2.1"
 tracing = "0.1.37"
 async-trait = "0.1.73"
 futures = "0.3.28"

cumulus/client/relay-chain-minimal-node/src/collator_overseer.rs

@@ -15,7 +15,7 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use futures::{select, StreamExt};
-use lru::LruCache;
+use schnellru::{ByLength, LruMap};
 use std::sync::Arc;
 
 use polkadot_availability_recovery::AvailabilityRecoverySubsystem;
@@ -157,7 +157,7 @@ fn build_overseer(
 		.span_per_active_leaf(Default::default())
 		.active_leaves(Default::default())
 		.supports_parachains(runtime_client)
-		.known_leaves(LruCache::new(KNOWN_LEAVES_CACHE_SIZE))
+		.known_leaves(LruMap::new(ByLength::new(KNOWN_LEAVES_CACHE_SIZE)))
 		.metrics(Metrics::register(registry)?)
 		.spawner(spawner);
 

cumulus/client/relay-chain-rpc-interface/Cargo.toml

@@ -34,7 +34,7 @@ async-trait = "0.1.73"
 url = "2.4.0"
 serde_json = "1.0.105"
 serde = "1.0.183"
-lru = "0.11.0"
+schnellru = "0.2.1"
 smoldot = { version = "0.11.0",  default_features = false, features = ["std"]}
 smoldot-light = { version = "0.9.0", default_features = false, features = ["std"] }
 either = "1.8.1"

cumulus/client/relay-chain-rpc-interface/src/reconnecting_ws_client.rs

@@ -31,10 +31,10 @@ use jsonrpsee::{
 	},
 	ws_client::WsClientBuilder,
 };
-use lru::LruCache;
 use sc_rpc_api::chain::ChainApiClient;
+use schnellru::{ByLength, LruMap};
 use sp_runtime::generic::SignedBlock;
-use std::{num::NonZeroUsize, sync::Arc};
+use std::sync::Arc;
 use tokio::sync::mpsc::{
 	channel as tokio_channel, Receiver as TokioReceiver, Sender as TokioSender,
 };
@@ -307,8 +307,7 @@ impl ReconnectingWebsocketWorker {
 			return
 		};
 
-		let mut imported_blocks_cache =
+		let mut imported_blocks_cache = LruMap::new(ByLength::new(40));
-			LruCache::new(NonZeroUsize::new(40).expect("40 is nonzero; qed."));
 		let mut should_reconnect = ConnectionStatus::Connected;
 		let mut last_seen_finalized_num: RelayNumber = 0;
 		loop {
@@ -365,7 +364,7 @@ impl ReconnectingWebsocketWorker {
 					match import_event {
 						Some(Ok(header)) => {
 							let hash = header.hash();
-							if imported_blocks_cache.contains(&hash) {
+							if imported_blocks_cache.peek(&hash).is_some() {
 								tracing::debug!(
 									target: LOG_TARGET,
 									number = header.number,
@@ -374,7 +373,7 @@ impl ReconnectingWebsocketWorker {
 								);
 								continue;
 							}
-							imported_blocks_cache.put(hash, ());
+							imported_blocks_cache.insert(hash, ());
 							distribute_header(header, &mut self.imported_header_listeners);
 						},
 						None => {

polkadot/node/core/approval-voting/Cargo.toml

@@ -11,7 +11,7 @@ futures-timer = "3.0.2"
 parity-scale-codec = { version = "3.6.1", default-features = false, features = ["bit-vec", "derive"] }
 gum = { package = "tracing-gum", path = "../../gum" }
 bitvec = { version = "1.0.0", default-features = false, features = ["alloc"] }
-lru = "0.11.0"
+schnellru = "0.2.1"
 merlin = "2.0"
 schnorrkel = "0.9.1"
 kvdb = "0.13.0"

polkadot/node/core/approval-voting/src/import.rs

@@ -643,7 +643,7 @@ pub(crate) mod tests {
 			blank_state(),
 			RuntimeInfo::new_with_config(RuntimeInfoConfig {
 				keystore: None,
-				session_cache_lru_size: DISPUTE_WINDOW.into(),
+				session_cache_lru_size: DISPUTE_WINDOW.get(),
 			}),
 		)
 	}
@@ -755,7 +755,7 @@ pub(crate) mod tests {
 
 			let mut runtime_info = RuntimeInfo::new_with_config(RuntimeInfoConfig {
 				keystore: None,
-				session_cache_lru_size: DISPUTE_WINDOW.into(),
+				session_cache_lru_size: DISPUTE_WINDOW.get(),
 			});
 
 			let header = header.clone();
@@ -878,7 +878,7 @@ pub(crate) mod tests {
 		let test_fut = {
 			let mut runtime_info = RuntimeInfo::new_with_config(RuntimeInfoConfig {
 				keystore: None,
-				session_cache_lru_size: DISPUTE_WINDOW.into(),
+				session_cache_lru_size: DISPUTE_WINDOW.get(),
 			});
 
 			let header = header.clone();
@@ -994,7 +994,7 @@ pub(crate) mod tests {
 		let test_fut = {
 			let mut runtime_info = RuntimeInfo::new_with_config(RuntimeInfoConfig {
 				keystore: None,
-				session_cache_lru_size: DISPUTE_WINDOW.into(),
+				session_cache_lru_size: DISPUTE_WINDOW.get(),
 			});
 
 			let header = header.clone();
@@ -1092,7 +1092,7 @@ pub(crate) mod tests {
 
 			let mut runtime_info = RuntimeInfo::new_with_config(RuntimeInfoConfig {
 				keystore: None,
-				session_cache_lru_size: DISPUTE_WINDOW.into(),
+				session_cache_lru_size: DISPUTE_WINDOW.get(),
 			});
 
 			let header = header.clone();

polkadot/node/core/approval-voting/src/lib.rs

@@ -69,11 +69,12 @@ use std::{
 	collections::{
 		btree_map::Entry as BTMEntry, hash_map::Entry as HMEntry, BTreeMap, HashMap, HashSet,
 	},
-	num::NonZeroUsize,
 	sync::Arc,
 	time::Duration,
 };
 
+use schnellru::{ByLength, LruMap};
+
 use approval_checking::RequiredTranches;
 use criteria::{AssignmentCriteria, RealAssignmentCriteria};
 use persisted_entries::{ApprovalEntry, BlockEntry, CandidateEntry};
@@ -102,10 +103,7 @@ const APPROVAL_CHECKING_TIMEOUT: Duration = Duration::from_secs(120);
 /// Value rather arbitrarily: Should not be hit in practice, it exists to more easily diagnose dead
 /// lock issues for example.
 const WAIT_FOR_SIGS_TIMEOUT: Duration = Duration::from_millis(500);
-const APPROVAL_CACHE_SIZE: NonZeroUsize = match NonZeroUsize::new(1024) {
+const APPROVAL_CACHE_SIZE: u32 = 1024;
-	Some(cap) => cap,
-	None => panic!("Approval cache size must be non-zero."),
-};
 
 const TICK_TOO_FAR_IN_FUTURE: Tick = 20; // 10 seconds.
 const APPROVAL_DELAY: Tick = 2;
@@ -627,7 +625,7 @@ impl CurrentlyCheckingSet {
 
 	pub async fn next(
 		&mut self,
-		approvals_cache: &mut lru::LruCache<CandidateHash, ApprovalOutcome>,
+		approvals_cache: &mut LruMap<CandidateHash, ApprovalOutcome>,
 	) -> (HashSet<Hash>, ApprovalState) {
 		if !self.currently_checking.is_empty() {
 			if let Some(approval_state) = self.currently_checking.next().await {
@@ -635,7 +633,8 @@ impl CurrentlyCheckingSet {
 					.candidate_hash_map
 					.remove(&approval_state.candidate_hash)
 					.unwrap_or_default();
-				approvals_cache.put(approval_state.candidate_hash, approval_state.approval_outcome);
+				approvals_cache
+					.insert(approval_state.candidate_hash, approval_state.approval_outcome);
 				return (out, approval_state)
 			}
 		}
@@ -782,11 +781,11 @@ where
 	// `None` on start-up. Gets initialized/updated on leaf update
 	let mut session_info_provider = RuntimeInfo::new_with_config(RuntimeInfoConfig {
 		keystore: None,
-		session_cache_lru_size: DISPUTE_WINDOW.into(),
+		session_cache_lru_size: DISPUTE_WINDOW.get(),
 	});
 	let mut wakeups = Wakeups::default();
 	let mut currently_checking_set = CurrentlyCheckingSet::default();
-	let mut approvals_cache = lru::LruCache::new(APPROVAL_CACHE_SIZE);
+	let mut approvals_cache = LruMap::new(ByLength::new(APPROVAL_CACHE_SIZE));
 
 	let mut last_finalized_height: Option<BlockNumber> = {
 		let (tx, rx) = oneshot::channel();
@@ -922,7 +921,7 @@ async fn handle_actions<Context>(
 	metrics: &Metrics,
 	wakeups: &mut Wakeups,
 	currently_checking_set: &mut CurrentlyCheckingSet,
-	approvals_cache: &mut lru::LruCache<CandidateHash, ApprovalOutcome>,
+	approvals_cache: &mut LruMap<CandidateHash, ApprovalOutcome>,
 	mode: &mut Mode,
 	actions: Vec<Action>,
 ) -> SubsystemResult<bool> {

polkadot/node/core/dispute-coordinator/Cargo.toml

@@ -11,7 +11,7 @@ gum = { package = "tracing-gum", path = "../../gum" }
 parity-scale-codec = "3.6.1"
 kvdb = "0.13.0"
 thiserror = "1.0.31"
-lru = "0.11.0"
+schnellru = "0.2.1"
 fatality = "0.0.6"
 
 polkadot-primitives = { path = "../../../primitives" }

polkadot/node/core/dispute-coordinator/src/lib.rs

@@ -25,7 +25,7 @@
 //! When importing a dispute vote from another node, this will trigger dispute participation to
 //! recover and validate the block.
 
-use std::{num::NonZeroUsize, sync::Arc};
+use std::sync::Arc;
 
 use futures::FutureExt;
 
@@ -222,8 +222,7 @@ impl DisputeCoordinatorSubsystem {
 			// keep all sessions for a dispute window
 			let mut runtime_info = RuntimeInfo::new_with_config(RuntimeInfoConfig {
 				keystore: None,
-				session_cache_lru_size: NonZeroUsize::new(DISPUTE_WINDOW.get() as usize)
+				session_cache_lru_size: DISPUTE_WINDOW.get(),
-					.expect("DISPUTE_WINDOW can't be 0; qed."),
 			});
 			let mut overlay_db = OverlayedBackend::new(&mut backend);
 			let (

polkadot/node/core/dispute-coordinator/src/scraping/mod.rs

@@ -14,13 +14,10 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::{
+use std::collections::{BTreeMap, HashSet};
-	collections::{BTreeMap, HashSet},
-	num::NonZeroUsize,
-};
 
 use futures::channel::oneshot;
-use lru::LruCache;
+use schnellru::{ByLength, LruMap};
 
 use polkadot_node_primitives::{DISPUTE_CANDIDATE_LIFETIME_AFTER_FINALIZATION, MAX_FINALITY_LAG};
 use polkadot_node_subsystem::{
@@ -52,10 +49,7 @@ mod candidates;
 /// `last_observed_blocks` LRU. This means, this value should the very least be as large as the
 /// number of expected forks for keeping chain scraping efficient. Making the LRU much larger than
 /// that has very limited use.
-const LRU_OBSERVED_BLOCKS_CAPACITY: NonZeroUsize = match NonZeroUsize::new(20) {
+const LRU_OBSERVED_BLOCKS_CAPACITY: u32 = 20;
-	Some(cap) => cap,
-	None => panic!("Observed blocks cache size must be non-zero"),
-};
 
 /// `ScrapedUpdates`
 ///
@@ -173,7 +167,7 @@ pub struct ChainScraper {
 	///
 	/// We assume that ancestors of cached blocks are already processed, i.e. we have saved
 	/// corresponding included candidates.
-	last_observed_blocks: LruCache<Hash, ()>,
+	last_observed_blocks: LruMap<Hash, ()>,
 	/// Maps included candidate hashes to one or more relay block heights and hashes.
 	/// These correspond to all the relay blocks which marked a candidate as included,
 	/// and are needed to apply reversions in case a dispute is concluded against the
@@ -202,7 +196,7 @@ impl ChainScraper {
 		let mut s = Self {
 			included_candidates: candidates::ScrapedCandidates::new(),
 			backed_candidates: candidates::ScrapedCandidates::new(),
-			last_observed_blocks: LruCache::new(LRU_OBSERVED_BLOCKS_CAPACITY),
+			last_observed_blocks: LruMap::new(ByLength::new(LRU_OBSERVED_BLOCKS_CAPACITY)),
 			inclusions: Inclusions::new(),
 		};
 		let update =
@@ -288,7 +282,7 @@ impl ChainScraper {
 			},
 		}
 
-		self.last_observed_blocks.put(activated.hash, ());
+		self.last_observed_blocks.insert(activated.hash, ());
 
 		Ok(scraped_updates)
 	}

polkadot/node/core/runtime-api/Cargo.toml

@@ -8,7 +8,7 @@ license.workspace = true
 [dependencies]
 futures = "0.3.21"
 gum = { package = "tracing-gum", path = "../../gum" }
-lru = "0.11.0"
+schnellru = "0.2.1"
 
 sp-consensus-babe = { path = "../../../../substrate/primitives/consensus/babe" }
 

polkadot/node/core/runtime-api/src/cache.rs

@@ -14,9 +14,9 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::{collections::btree_map::BTreeMap, num::NonZeroUsize};
+use std::collections::btree_map::BTreeMap;
 
-use lru::LruCache;
+use schnellru::{ByLength, LruMap};
 use sp_consensus_babe::Epoch;
 
 use polkadot_primitives::{
@@ -32,77 +32,74 @@ use polkadot_primitives::{
 /// much if finality stalls (we only query state for unfinalized blocks + maybe latest finalized).
 /// In any case, a cache is an optimization. We should avoid a situation where having a large cache
 /// leads to OOM or puts pressure on other important stuff like PVF execution/preparation.
-const DEFAULT_CACHE_CAP: NonZeroUsize = match NonZeroUsize::new(128) {
+const DEFAULT_CACHE_CAP: u32 = 128;
-	Some(cap) => cap,
-	None => panic!("lru capacity must be non-zero"),
-};
 
 pub(crate) struct RequestResultCache {
-	authorities: LruCache<Hash, Vec<AuthorityDiscoveryId>>,
+	authorities: LruMap<Hash, Vec<AuthorityDiscoveryId>>,
-	validators: LruCache<Hash, Vec<ValidatorId>>,
+	validators: LruMap<Hash, Vec<ValidatorId>>,
-	validator_groups: LruCache<Hash, (Vec<Vec<ValidatorIndex>>, GroupRotationInfo)>,
+	validator_groups: LruMap<Hash, (Vec<Vec<ValidatorIndex>>, GroupRotationInfo)>,
-	availability_cores: LruCache<Hash, Vec<CoreState>>,
+	availability_cores: LruMap<Hash, Vec<CoreState>>,
 	persisted_validation_data:
-		LruCache<(Hash, ParaId, OccupiedCoreAssumption), Option<PersistedValidationData>>,
+		LruMap<(Hash, ParaId, OccupiedCoreAssumption), Option<PersistedValidationData>>,
 	assumed_validation_data:
-		LruCache<(ParaId, Hash), Option<(PersistedValidationData, ValidationCodeHash)>>,
+		LruMap<(ParaId, Hash), Option<(PersistedValidationData, ValidationCodeHash)>>,
-	check_validation_outputs: LruCache<(Hash, ParaId, CandidateCommitments), bool>,
+	check_validation_outputs: LruMap<(Hash, ParaId, CandidateCommitments), bool>,
-	session_index_for_child: LruCache<Hash, SessionIndex>,
+	session_index_for_child: LruMap<Hash, SessionIndex>,
-	validation_code: LruCache<(Hash, ParaId, OccupiedCoreAssumption), Option<ValidationCode>>,
+	validation_code: LruMap<(Hash, ParaId, OccupiedCoreAssumption), Option<ValidationCode>>,
-	validation_code_by_hash: LruCache<ValidationCodeHash, Option<ValidationCode>>,
+	validation_code_by_hash: LruMap<ValidationCodeHash, Option<ValidationCode>>,
-	candidate_pending_availability: LruCache<(Hash, ParaId), Option<CommittedCandidateReceipt>>,
+	candidate_pending_availability: LruMap<(Hash, ParaId), Option<CommittedCandidateReceipt>>,
-	candidate_events: LruCache<Hash, Vec<CandidateEvent>>,
+	candidate_events: LruMap<Hash, Vec<CandidateEvent>>,
-	session_executor_params: LruCache<SessionIndex, Option<ExecutorParams>>,
+	session_executor_params: LruMap<SessionIndex, Option<ExecutorParams>>,
-	session_info: LruCache<SessionIndex, SessionInfo>,
+	session_info: LruMap<SessionIndex, SessionInfo>,
-	dmq_contents: LruCache<(Hash, ParaId), Vec<InboundDownwardMessage<BlockNumber>>>,
+	dmq_contents: LruMap<(Hash, ParaId), Vec<InboundDownwardMessage<BlockNumber>>>,
 	inbound_hrmp_channels_contents:
-		LruCache<(Hash, ParaId), BTreeMap<ParaId, Vec<InboundHrmpMessage<BlockNumber>>>>,
+		LruMap<(Hash, ParaId), BTreeMap<ParaId, Vec<InboundHrmpMessage<BlockNumber>>>>,
-	current_babe_epoch: LruCache<Hash, Epoch>,
+	current_babe_epoch: LruMap<Hash, Epoch>,
-	on_chain_votes: LruCache<Hash, Option<ScrapedOnChainVotes>>,
+	on_chain_votes: LruMap<Hash, Option<ScrapedOnChainVotes>>,
-	pvfs_require_precheck: LruCache<Hash, Vec<ValidationCodeHash>>,
+	pvfs_require_precheck: LruMap<Hash, Vec<ValidationCodeHash>>,
 	validation_code_hash:
-		LruCache<(Hash, ParaId, OccupiedCoreAssumption), Option<ValidationCodeHash>>,
+		LruMap<(Hash, ParaId, OccupiedCoreAssumption), Option<ValidationCodeHash>>,
-	version: LruCache<Hash, u32>,
+	version: LruMap<Hash, u32>,
-	disputes: LruCache<Hash, Vec<(SessionIndex, CandidateHash, DisputeState<BlockNumber>)>>,
+	disputes: LruMap<Hash, Vec<(SessionIndex, CandidateHash, DisputeState<BlockNumber>)>>,
 	unapplied_slashes:
-		LruCache<Hash, Vec<(SessionIndex, CandidateHash, vstaging::slashing::PendingSlashes)>>,
+		LruMap<Hash, Vec<(SessionIndex, CandidateHash, vstaging::slashing::PendingSlashes)>>,
 	key_ownership_proof:
-		LruCache<(Hash, ValidatorId), Option<vstaging::slashing::OpaqueKeyOwnershipProof>>,
+		LruMap<(Hash, ValidatorId), Option<vstaging::slashing::OpaqueKeyOwnershipProof>>,
 
-	staging_para_backing_state: LruCache<(Hash, ParaId), Option<vstaging::BackingState>>,
+	staging_para_backing_state: LruMap<(Hash, ParaId), Option<vstaging::BackingState>>,
-	staging_async_backing_params: LruCache<Hash, vstaging::AsyncBackingParams>,
+	staging_async_backing_params: LruMap<Hash, vstaging::AsyncBackingParams>,
 }
 
 impl Default for RequestResultCache {
 	fn default() -> Self {
 		Self {
-			authorities: LruCache::new(DEFAULT_CACHE_CAP),
+			authorities: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			validators: LruCache::new(DEFAULT_CACHE_CAP),
+			validators: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			validator_groups: LruCache::new(DEFAULT_CACHE_CAP),
+			validator_groups: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			availability_cores: LruCache::new(DEFAULT_CACHE_CAP),
+			availability_cores: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			persisted_validation_data: LruCache::new(DEFAULT_CACHE_CAP),
+			persisted_validation_data: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			assumed_validation_data: LruCache::new(DEFAULT_CACHE_CAP),
+			assumed_validation_data: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			check_validation_outputs: LruCache::new(DEFAULT_CACHE_CAP),
+			check_validation_outputs: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			session_index_for_child: LruCache::new(DEFAULT_CACHE_CAP),
+			session_index_for_child: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			validation_code: LruCache::new(DEFAULT_CACHE_CAP),
+			validation_code: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			validation_code_by_hash: LruCache::new(DEFAULT_CACHE_CAP),
+			validation_code_by_hash: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			candidate_pending_availability: LruCache::new(DEFAULT_CACHE_CAP),
+			candidate_pending_availability: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			candidate_events: LruCache::new(DEFAULT_CACHE_CAP),
+			candidate_events: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			session_executor_params: LruCache::new(DEFAULT_CACHE_CAP),
+			session_executor_params: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			session_info: LruCache::new(DEFAULT_CACHE_CAP),
+			session_info: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			dmq_contents: LruCache::new(DEFAULT_CACHE_CAP),
+			dmq_contents: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			inbound_hrmp_channels_contents: LruCache::new(DEFAULT_CACHE_CAP),
+			inbound_hrmp_channels_contents: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			current_babe_epoch: LruCache::new(DEFAULT_CACHE_CAP),
+			current_babe_epoch: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			on_chain_votes: LruCache::new(DEFAULT_CACHE_CAP),
+			on_chain_votes: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			pvfs_require_precheck: LruCache::new(DEFAULT_CACHE_CAP),
+			pvfs_require_precheck: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			validation_code_hash: LruCache::new(DEFAULT_CACHE_CAP),
+			validation_code_hash: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			version: LruCache::new(DEFAULT_CACHE_CAP),
+			version: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			disputes: LruCache::new(DEFAULT_CACHE_CAP),
+			disputes: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			unapplied_slashes: LruCache::new(DEFAULT_CACHE_CAP),
+			unapplied_slashes: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			key_ownership_proof: LruCache::new(DEFAULT_CACHE_CAP),
+			key_ownership_proof: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
 
-			staging_para_backing_state: LruCache::new(DEFAULT_CACHE_CAP),
+			staging_para_backing_state: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
-			staging_async_backing_params: LruCache::new(DEFAULT_CACHE_CAP),
+			staging_async_backing_params: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
 		}
 	}
 }
@@ -112,7 +109,7 @@ impl RequestResultCache {
 		&mut self,
 		relay_parent: &Hash,
 	) -> Option<&Vec<AuthorityDiscoveryId>> {
-		self.authorities.get(relay_parent)
+		self.authorities.get(relay_parent).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_authorities(
@@ -120,22 +117,22 @@ impl RequestResultCache {
 		relay_parent: Hash,
 		authorities: Vec<AuthorityDiscoveryId>,
 	) {
-		self.authorities.put(relay_parent, authorities);
+		self.authorities.insert(relay_parent, authorities);
 	}
 
 	pub(crate) fn validators(&mut self, relay_parent: &Hash) -> Option<&Vec<ValidatorId>> {
-		self.validators.get(relay_parent)
+		self.validators.get(relay_parent).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_validators(&mut self, relay_parent: Hash, validators: Vec<ValidatorId>) {
-		self.validators.put(relay_parent, validators);
+		self.validators.insert(relay_parent, validators);
 	}
 
 	pub(crate) fn validator_groups(
 		&mut self,
 		relay_parent: &Hash,
 	) -> Option<&(Vec<Vec<ValidatorIndex>>, GroupRotationInfo)> {
-		self.validator_groups.get(relay_parent)
+		self.validator_groups.get(relay_parent).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_validator_groups(
@@ -143,22 +140,22 @@ impl RequestResultCache {
 		relay_parent: Hash,
 		groups: (Vec<Vec<ValidatorIndex>>, GroupRotationInfo),
 	) {
-		self.validator_groups.put(relay_parent, groups);
+		self.validator_groups.insert(relay_parent, groups);
 	}
 
 	pub(crate) fn availability_cores(&mut self, relay_parent: &Hash) -> Option<&Vec<CoreState>> {
-		self.availability_cores.get(relay_parent)
+		self.availability_cores.get(relay_parent).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_availability_cores(&mut self, relay_parent: Hash, cores: Vec<CoreState>) {
-		self.availability_cores.put(relay_parent, cores);
+		self.availability_cores.insert(relay_parent, cores);
 	}
 
 	pub(crate) fn persisted_validation_data(
 		&mut self,
 		key: (Hash, ParaId, OccupiedCoreAssumption),
 	) -> Option<&Option<PersistedValidationData>> {
-		self.persisted_validation_data.get(&key)
+		self.persisted_validation_data.get(&key).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_persisted_validation_data(
@@ -166,14 +163,14 @@ impl RequestResultCache {
 		key: (Hash, ParaId, OccupiedCoreAssumption),
 		data: Option<PersistedValidationData>,
 	) {
-		self.persisted_validation_data.put(key, data);
+		self.persisted_validation_data.insert(key, data);
 	}
 
 	pub(crate) fn assumed_validation_data(
 		&mut self,
 		key: (Hash, ParaId, Hash),
 	) -> Option<&Option<(PersistedValidationData, ValidationCodeHash)>> {
-		self.assumed_validation_data.get(&(key.1, key.2))
+		self.assumed_validation_data.get(&(key.1, key.2)).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_assumed_validation_data(
@@ -181,14 +178,14 @@ impl RequestResultCache {
 		key: (ParaId, Hash),
 		data: Option<(PersistedValidationData, ValidationCodeHash)>,
 	) {
-		self.assumed_validation_data.put(key, data);
+		self.assumed_validation_data.insert(key, data);
 	}
 
 	pub(crate) fn check_validation_outputs(
 		&mut self,
 		key: (Hash, ParaId, CandidateCommitments),
 	) -> Option<&bool> {
-		self.check_validation_outputs.get(&key)
+		self.check_validation_outputs.get(&key).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_check_validation_outputs(
@@ -196,11 +193,11 @@ impl RequestResultCache {
 		key: (Hash, ParaId, CandidateCommitments),
 		value: bool,
 	) {
-		self.check_validation_outputs.put(key, value);
+		self.check_validation_outputs.insert(key, value);
 	}
 
 	pub(crate) fn session_index_for_child(&mut self, relay_parent: &Hash) -> Option<&SessionIndex> {
-		self.session_index_for_child.get(relay_parent)
+		self.session_index_for_child.get(relay_parent).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_session_index_for_child(
@@ -208,14 +205,14 @@ impl RequestResultCache {
 		relay_parent: Hash,
 		index: SessionIndex,
 	) {
-		self.session_index_for_child.put(relay_parent, index);
+		self.session_index_for_child.insert(relay_parent, index);
 	}
 
 	pub(crate) fn validation_code(
 		&mut self,
 		key: (Hash, ParaId, OccupiedCoreAssumption),
 	) -> Option<&Option<ValidationCode>> {
-		self.validation_code.get(&key)
+		self.validation_code.get(&key).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_validation_code(
@@ -223,7 +220,7 @@ impl RequestResultCache {
 		key: (Hash, ParaId, OccupiedCoreAssumption),
 		value: Option<ValidationCode>,
 	) {
-		self.validation_code.put(key, value);
+		self.validation_code.insert(key, value);
 	}
 
 	// the actual key is `ValidationCodeHash` (`Hash` is ignored),
@@ -232,7 +229,7 @@ impl RequestResultCache {
 		&mut self,
 		key: (Hash, ValidationCodeHash),
 	) -> Option<&Option<ValidationCode>> {
-		self.validation_code_by_hash.get(&key.1)
+		self.validation_code_by_hash.get(&key.1).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_validation_code_by_hash(
@@ -240,14 +237,14 @@ impl RequestResultCache {
 		key: ValidationCodeHash,
 		value: Option<ValidationCode>,
 	) {
-		self.validation_code_by_hash.put(key, value);
+		self.validation_code_by_hash.insert(key, value);
 	}
 
 	pub(crate) fn candidate_pending_availability(
 		&mut self,
 		key: (Hash, ParaId),
 	) -> Option<&Option<CommittedCandidateReceipt>> {
-		self.candidate_pending_availability.get(&key)
+		self.candidate_pending_availability.get(&key).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_candidate_pending_availability(
@@ -255,11 +252,11 @@ impl RequestResultCache {
 		key: (Hash, ParaId),
 		value: Option<CommittedCandidateReceipt>,
 	) {
-		self.candidate_pending_availability.put(key, value);
+		self.candidate_pending_availability.insert(key, value);
 	}
 
 	pub(crate) fn candidate_events(&mut self, relay_parent: &Hash) -> Option<&Vec<CandidateEvent>> {
-		self.candidate_events.get(relay_parent)
+		self.candidate_events.get(relay_parent).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_candidate_events(
@@ -267,22 +264,22 @@ impl RequestResultCache {
 		relay_parent: Hash,
 		events: Vec<CandidateEvent>,
 	) {
-		self.candidate_events.put(relay_parent, events);
+		self.candidate_events.insert(relay_parent, events);
 	}
 
 	pub(crate) fn session_info(&mut self, key: SessionIndex) -> Option<&SessionInfo> {
-		self.session_info.get(&key)
+		self.session_info.get(&key).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_session_info(&mut self, key: SessionIndex, value: SessionInfo) {
-		self.session_info.put(key, value);
+		self.session_info.insert(key, value);
 	}
 
 	pub(crate) fn session_executor_params(
 		&mut self,
 		session_index: SessionIndex,
 	) -> Option<&Option<ExecutorParams>> {
-		self.session_executor_params.get(&session_index)
+		self.session_executor_params.get(&session_index).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_session_executor_params(
@@ -290,14 +287,14 @@ impl RequestResultCache {
 		session_index: SessionIndex,
 		value: Option<ExecutorParams>,
 	) {
-		self.session_executor_params.put(session_index, value);
+		self.session_executor_params.insert(session_index, value);
 	}
 
 	pub(crate) fn dmq_contents(
 		&mut self,
 		key: (Hash, ParaId),
 	) -> Option<&Vec<InboundDownwardMessage<BlockNumber>>> {
-		self.dmq_contents.get(&key)
+		self.dmq_contents.get(&key).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_dmq_contents(
@@ -305,14 +302,14 @@ impl RequestResultCache {
 		key: (Hash, ParaId),
 		value: Vec<InboundDownwardMessage<BlockNumber>>,
 	) {
-		self.dmq_contents.put(key, value);
+		self.dmq_contents.insert(key, value);
 	}
 
 	pub(crate) fn inbound_hrmp_channels_contents(
 		&mut self,
 		key: (Hash, ParaId),
 	) -> Option<&BTreeMap<ParaId, Vec<InboundHrmpMessage<BlockNumber>>>> {
-		self.inbound_hrmp_channels_contents.get(&key)
+		self.inbound_hrmp_channels_contents.get(&key).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_inbound_hrmp_channel_contents(
@@ -320,22 +317,22 @@ impl RequestResultCache {
 		key: (Hash, ParaId),
 		value: BTreeMap<ParaId, Vec<InboundHrmpMessage<BlockNumber>>>,
 	) {
-		self.inbound_hrmp_channels_contents.put(key, value);
+		self.inbound_hrmp_channels_contents.insert(key, value);
 	}
 
 	pub(crate) fn current_babe_epoch(&mut self, relay_parent: &Hash) -> Option<&Epoch> {
-		self.current_babe_epoch.get(relay_parent)
+		self.current_babe_epoch.get(relay_parent).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_current_babe_epoch(&mut self, relay_parent: Hash, epoch: Epoch) {
-		self.current_babe_epoch.put(relay_parent, epoch);
+		self.current_babe_epoch.insert(relay_parent, epoch);
 	}
 
 	pub(crate) fn on_chain_votes(
 		&mut self,
 		relay_parent: &Hash,
 	) -> Option<&Option<ScrapedOnChainVotes>> {
-		self.on_chain_votes.get(relay_parent)
+		self.on_chain_votes.get(relay_parent).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_on_chain_votes(
@@ -343,14 +340,14 @@ impl RequestResultCache {
 		relay_parent: Hash,
 		scraped: Option<ScrapedOnChainVotes>,
 	) {
-		self.on_chain_votes.put(relay_parent, scraped);
+		self.on_chain_votes.insert(relay_parent, scraped);
 	}
 
 	pub(crate) fn pvfs_require_precheck(
 		&mut self,
 		relay_parent: &Hash,
 	) -> Option<&Vec<ValidationCodeHash>> {
-		self.pvfs_require_precheck.get(relay_parent)
+		self.pvfs_require_precheck.get(relay_parent).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_pvfs_require_precheck(
@@ -358,14 +355,14 @@ impl RequestResultCache {
 		relay_parent: Hash,
 		pvfs: Vec<ValidationCodeHash>,
 	) {
-		self.pvfs_require_precheck.put(relay_parent, pvfs);
+		self.pvfs_require_precheck.insert(relay_parent, pvfs);
 	}
 
 	pub(crate) fn validation_code_hash(
 		&mut self,
 		key: (Hash, ParaId, OccupiedCoreAssumption),
 	) -> Option<&Option<ValidationCodeHash>> {
-		self.validation_code_hash.get(&key)
+		self.validation_code_hash.get(&key).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_validation_code_hash(
@@ -373,22 +370,22 @@ impl RequestResultCache {
 		key: (Hash, ParaId, OccupiedCoreAssumption),
 		value: Option<ValidationCodeHash>,
 	) {
-		self.validation_code_hash.put(key, value);
+		self.validation_code_hash.insert(key, value);
 	}
 
 	pub(crate) fn version(&mut self, relay_parent: &Hash) -> Option<&u32> {
-		self.version.get(relay_parent)
+		self.version.get(relay_parent).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_version(&mut self, key: Hash, value: u32) {
-		self.version.put(key, value);
+		self.version.insert(key, value);
 	}
 
 	pub(crate) fn disputes(
 		&mut self,
 		relay_parent: &Hash,
 	) -> Option<&Vec<(SessionIndex, CandidateHash, DisputeState<BlockNumber>)>> {
-		self.disputes.get(relay_parent)
+		self.disputes.get(relay_parent).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_disputes(
@@ -396,14 +393,14 @@ impl RequestResultCache {
 		relay_parent: Hash,
 		value: Vec<(SessionIndex, CandidateHash, DisputeState<BlockNumber>)>,
 	) {
-		self.disputes.put(relay_parent, value);
+		self.disputes.insert(relay_parent, value);
 	}
 
 	pub(crate) fn unapplied_slashes(
 		&mut self,
 		relay_parent: &Hash,
 	) -> Option<&Vec<(SessionIndex, CandidateHash, vstaging::slashing::PendingSlashes)>> {
-		self.unapplied_slashes.get(relay_parent)
+		self.unapplied_slashes.get(relay_parent).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_unapplied_slashes(
@@ -411,14 +408,14 @@ impl RequestResultCache {
 		relay_parent: Hash,
 		value: Vec<(SessionIndex, CandidateHash, vstaging::slashing::PendingSlashes)>,
 	) {
-		self.unapplied_slashes.put(relay_parent, value);
+		self.unapplied_slashes.insert(relay_parent, value);
 	}
 
 	pub(crate) fn key_ownership_proof(
 		&mut self,
 		key: (Hash, ValidatorId),
 	) -> Option<&Option<vstaging::slashing::OpaqueKeyOwnershipProof>> {
-		self.key_ownership_proof.get(&key)
+		self.key_ownership_proof.get(&key).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_key_ownership_proof(
@@ -426,7 +423,7 @@ impl RequestResultCache {
 		key: (Hash, ValidatorId),
 		value: Option<vstaging::slashing::OpaqueKeyOwnershipProof>,
 	) {
-		self.key_ownership_proof.put(key, value);
+		self.key_ownership_proof.insert(key, value);
 	}
 
 	// This request is never cached, hence always returns `None`.
@@ -441,7 +438,7 @@ impl RequestResultCache {
 		&mut self,
 		key: (Hash, ParaId),
 	) -> Option<&Option<vstaging::BackingState>> {
-		self.staging_para_backing_state.get(&key)
+		self.staging_para_backing_state.get(&key).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_staging_para_backing_state(
@@ -449,14 +446,14 @@ impl RequestResultCache {
 		key: (Hash, ParaId),
 		value: Option<vstaging::BackingState>,
 	) {
-		self.staging_para_backing_state.put(key, value);
+		self.staging_para_backing_state.insert(key, value);
 	}
 
 	pub(crate) fn staging_async_backing_params(
 		&mut self,
 		key: &Hash,
 	) -> Option<&vstaging::AsyncBackingParams> {
-		self.staging_async_backing_params.get(key)
+		self.staging_async_backing_params.get(key).map(|v| &*v)
 	}
 
 	pub(crate) fn cache_staging_async_backing_params(
@@ -464,7 +461,7 @@ impl RequestResultCache {
 		key: Hash,
 		value: vstaging::AsyncBackingParams,
 	) {
-		self.staging_async_backing_params.put(key, value);
+		self.staging_async_backing_params.insert(key, value);
 	}
 }
 

polkadot/node/network/availability-distribution/Cargo.toml

@@ -20,7 +20,7 @@ sp-keystore = { path = "../../../../substrate/primitives/keystore" }
 thiserror = "1.0.31"
 rand = "0.8.5"
 derive_more = "0.99.17"
-lru = "0.11.0"
+schnellru = "0.2.1"
 fatality = "0.0.6"
 
 [dev-dependencies]

polkadot/node/network/availability-distribution/src/requester/session_cache.rs

@@ -14,10 +14,10 @@
 // You should have received a copy of the GNU General Public License
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
-use std::{collections::HashSet, num::NonZeroUsize};
+use std::collections::HashSet;
 
-use lru::LruCache;
 use rand::{seq::SliceRandom, thread_rng};
+use schnellru::{ByLength, LruMap};
 
 use polkadot_node_subsystem::overseer;
 use polkadot_node_subsystem_util::runtime::RuntimeInfo;
@@ -37,7 +37,7 @@ pub struct SessionCache {
 	/// Note: Performance of fetching is really secondary here, but we need to ensure we are going
 	/// to get any existing cache entry, before fetching new information, as we should not mess up
 	/// the order of validators in `SessionInfo::validator_groups`.
-	session_info_cache: LruCache<SessionIndex, SessionInfo>,
+	session_info_cache: LruMap<SessionIndex, SessionInfo>,
 }
 
 /// Localized session information, tailored for the needs of availability distribution.
@@ -83,7 +83,7 @@ impl SessionCache {
 	pub fn new() -> Self {
 		SessionCache {
 			// We need to cache the current and the last session the most:
-			session_info_cache: LruCache::new(NonZeroUsize::new(2).unwrap()),
+			session_info_cache: LruMap::new(ByLength::new(2)),
 		}
 	}
 
@@ -115,7 +115,7 @@ impl SessionCache {
 			gum::trace!(target: LOG_TARGET, session_index, "Calling `with_info`");
 			let r = with_info(&info);
 			gum::trace!(target: LOG_TARGET, session_index, "Storing session info in lru!");
-			self.session_info_cache.put(session_index, info);
+			self.session_info_cache.insert(session_index, info);
 			Ok(Some(r))
 		} else {
 			Ok(None)
@@ -142,7 +142,7 @@ impl SessionCache {
 	/// will be put at the beginning of the group.
 	pub fn report_bad(&mut self, report: BadValidators) -> Result<()> {
 		let available_sessions = self.session_info_cache.iter().map(|(k, _)| *k).collect();
-		let session = self.session_info_cache.get_mut(&report.session_index).ok_or(
+		let session = self.session_info_cache.get(&report.session_index).ok_or(
 			Error::NoSuchCachedSession {
 				available_sessions,
 				missing_session: report.session_index,

polkadot/node/network/availability-recovery/Cargo.toml

@@ -7,7 +7,7 @@ license.workspace = true
 
 [dependencies]
 futures = "0.3.21"
-lru = "0.11.0"
+schnellru = "0.2.1"
 rand = "0.8.5"
 fatality = "0.0.6"
 thiserror = "1.0.31"

polkadot/node/network/availability-recovery/src/lib.rs

@@ -35,8 +35,8 @@ use futures::{
 	stream::{FuturesUnordered, StreamExt},
 	task::{Context, Poll},
 };
-use lru::LruCache;
 use rand::seq::SliceRandom;
+use schnellru::{ByLength, LruMap};
 
 use fatality::Nested;
 use polkadot_erasure_coding::{
@@ -82,10 +82,7 @@ const LOG_TARGET: &str = "parachain::availability-recovery";
 const N_PARALLEL: usize = 50;
 
 // Size of the LRU cache where we keep recovered data.
-const LRU_SIZE: NonZeroUsize = match NonZeroUsize::new(16) {
+const LRU_SIZE: u32 = 16;
-	Some(cap) => cap,
-	None => panic!("Availability-recovery cache size must be non-zero."),
-};
 
 const COST_INVALID_REQUEST: Rep = Rep::CostMajor("Peer sent unparsable request");
 
@@ -927,7 +924,7 @@ struct State {
 	live_block: (BlockNumber, Hash),
 
 	/// An LRU cache of recently recovered data.
-	availability_lru: LruCache<CandidateHash, CachedRecovery>,
+	availability_lru: LruMap<CandidateHash, CachedRecovery>,
 }
 
 impl Default for State {
@@ -935,7 +932,7 @@ impl Default for State {
 		Self {
 			ongoing_recoveries: FuturesUnordered::new(),
 			live_block: (0, Hash::default()),
-			availability_lru: LruCache::new(LRU_SIZE),
+			availability_lru: LruMap::new(ByLength::new(LRU_SIZE)),
 		}
 	}
 }
@@ -1334,7 +1331,7 @@ impl AvailabilityRecoverySubsystem {
 				output = state.ongoing_recoveries.select_next_some() => {
 					if let Some((candidate_hash, result)) = output {
 						if let Ok(recovery) = CachedRecovery::try_from(result) {
-							state.availability_lru.put(candidate_hash, recovery);
+							state.availability_lru.insert(candidate_hash, recovery);
 						}
 					}
 				}

polkadot/node/network/dispute-distribution/Cargo.toml

@@ -22,7 +22,7 @@ sp-application-crypto = { path = "../../../../substrate/primitives/application-c
 sp-keystore = { path = "../../../../substrate/primitives/keystore" }
 thiserror = "1.0.31"
 fatality = "0.0.6"
-lru = "0.11.0"
+schnellru = "0.2.1"
 indexmap = "1.9.1"
 
 [dev-dependencies]

polkadot/node/network/dispute-distribution/src/lib.rs

@@ -24,7 +24,7 @@
 //! The sender is responsible for getting our vote out, see [`sender`]. The receiver handles
 //! incoming [`DisputeRequest`]s and offers spam protection, see [`receiver`].
 
-use std::{num::NonZeroUsize, time::Duration};
+use std::time::Duration;
 
 use futures::{channel::mpsc, FutureExt, StreamExt, TryFutureExt};
 
@@ -165,8 +165,7 @@ where
 	) -> Self {
 		let runtime = RuntimeInfo::new_with_config(runtime::Config {
 			keystore: Some(keystore),
-			session_cache_lru_size: NonZeroUsize::new(DISPUTE_WINDOW.get() as usize)
+			session_cache_lru_size: DISPUTE_WINDOW.get(),
-				.expect("Dispute window can not be 0; qed"),
 		});
 		let (tx, sender_rx) = NestingSender::new_root(1);
 		let disputes_sender = DisputeSender::new(tx, metrics.clone());

polkadot/node/network/dispute-distribution/src/receiver/mod.rs

@@ -15,7 +15,6 @@
 // along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
 
 use std::{
-	num::NonZeroUsize,
 	pin::Pin,
 	task::{Context, Poll},
 	time::Duration,
@@ -161,8 +160,7 @@ where
 	) -> Self {
 		let runtime = RuntimeInfo::new_with_config(runtime::Config {
 			keystore: None,
-			session_cache_lru_size: NonZeroUsize::new(DISPUTE_WINDOW.get() as usize)
+			session_cache_lru_size: DISPUTE_WINDOW.get(),
-				.expect("Dispute window can not be 0; qed"),
 		});
 		Self {
 			runtime,

polkadot/node/overseer/Cargo.toml

@@ -18,7 +18,7 @@ polkadot-node-metrics = { path = "../metrics" }
 polkadot-primitives = { path = "../../primitives" }
 orchestra = "0.0.5"
 gum = { package = "tracing-gum", path = "../gum" }
-lru = "0.11.0"
+schnellru = "0.2.1"
 sp-core = { path = "../../../substrate/primitives/core" }
 async-trait = "0.1.57"
 tikv-jemalloc-ctl = { version = "0.5.0", optional = true }

polkadot/node/overseer/src/dummy.rs

@@ -19,9 +19,9 @@ use crate::{
 	Overseer, OverseerMetrics, OverseerSignal, OverseerSubsystemContext, SpawnGlue,
 	KNOWN_LEAVES_CACHE_SIZE,
 };
-use lru::LruCache;
 use orchestra::{FromOrchestra, SpawnedSubsystem, Subsystem, SubsystemContext};
 use polkadot_node_subsystem_types::{errors::SubsystemError, messages::*};
+use schnellru::{ByLength, LruMap};
 // Generated dummy messages
 use crate::messages::*;
 
@@ -193,7 +193,7 @@ where
 		.activation_external_listeners(Default::default())
 		.span_per_active_leaf(Default::default())
 		.active_leaves(Default::default())
-		.known_leaves(LruCache::new(KNOWN_LEAVES_CACHE_SIZE))
+		.known_leaves(LruMap::new(ByLength::new(KNOWN_LEAVES_CACHE_SIZE)))
 		.spawner(SpawnGlue(spawner))
 		.metrics(metrics)
 		.supports_parachains(supports_parachains);

polkadot/node/overseer/src/lib.rs

@@ -62,14 +62,13 @@
 use std::{
 	collections::{hash_map, HashMap},
 	fmt::{self, Debug},
-	num::NonZeroUsize,
 	pin::Pin,
 	sync::Arc,
 	time::Duration,
 };
 
 use futures::{channel::oneshot, future::BoxFuture, select, Future, FutureExt, StreamExt};
-use lru::LruCache;
+use schnellru::LruMap;
 
 use client::{BlockImportNotification, BlockchainEvents, FinalityNotification};
 use polkadot_primitives::{Block, BlockNumber, Hash};
@@ -113,10 +112,7 @@ pub use orchestra::{
 
 /// Store 2 days worth of blocks, not accounting for forks,
 /// in the LRU cache. Assumes a 6-second block time.
-pub const KNOWN_LEAVES_CACHE_SIZE: NonZeroUsize = match NonZeroUsize::new(2 * 24 * 3600 / 6) {
+pub const KNOWN_LEAVES_CACHE_SIZE: u32 = 2 * 24 * 3600 / 6;
-	Some(cap) => cap,
-	None => panic!("Known leaves cache size must be non-zero"),
-};
 
 #[cfg(any(target_os = "linux", feature = "jemalloc-allocator"))]
 mod memory_stats;
@@ -632,7 +628,7 @@ pub struct Overseer<SupportsParachains> {
 	pub supports_parachains: SupportsParachains,
 
 	/// An LRU cache for keeping track of relay-chain heads that have already been seen.
-	pub known_leaves: LruCache<Hash, ()>,
+	pub known_leaves: LruMap<Hash, ()>,
 
 	/// Various Prometheus metrics.
 	pub metrics: OverseerMetrics,
@@ -880,9 +876,10 @@ where
 		let span = Arc::new(span);
 		self.span_per_active_leaf.insert(*hash, span.clone());
 
-		let status = if let Some(_) = self.known_leaves.put(*hash, ()) {
+		let status = if self.known_leaves.get(hash).is_some() {
 			LeafStatus::Stale
 		} else {
+			self.known_leaves.insert(*hash, ());
 			LeafStatus::Fresh
 		};
 

polkadot/node/primitives/src/lib.rs

@@ -22,7 +22,7 @@
 
 #![deny(missing_docs)]
 
-use std::{num::NonZeroUsize, pin::Pin};
+use std::pin::Pin;
 
 use bounded_vec::BoundedVec;
 use futures::Future;
@@ -143,12 +143,6 @@ impl SessionWindowSize {
 	}
 }
 
-impl From<SessionWindowSize> for NonZeroUsize {
-	fn from(value: SessionWindowSize) -> Self {
-		NonZeroUsize::new(value.get() as usize).expect("SessionWindowSize can't be 0. qed.")
-	}
-}
-
 /// The cumulative weight of a block in a fork-choice rule.
 pub type BlockWeight = u32;
 

polkadot/node/service/Cargo.toml

@@ -86,7 +86,7 @@ parity-db = { version = "0.4.8", optional = true }
 codec = { package = "parity-scale-codec", version = "3.6.1" }
 
 async-trait = "0.1.57"
-lru = "0.11.0"
+schnellru = "0.2.1"
 log = "0.4.17"
 is_executable = "1.0.1"
 

polkadot/node/service/src/overseer.rs

@@ -19,7 +19,6 @@ use polkadot_node_subsystem_types::DefaultSubsystemClient;
 use sc_transaction_pool_api::OffchainTransactionPoolFactory;
 use sp_core::traits::SpawnNamed;
 
-use lru::LruCache;
 use polkadot_availability_distribution::IncomingRequestReceivers;
 use polkadot_node_core_approval_voting::Config as ApprovalVotingConfig;
 use polkadot_node_core_av_store::Config as AvailabilityConfig;
@@ -41,6 +40,7 @@ use polkadot_overseer::{
 	metrics::Metrics as OverseerMetrics, InitializedOverseerBuilder, MetricsTrait, Overseer,
 	OverseerConnector, OverseerHandle, SpawnGlue,
 };
+use schnellru::{ByLength, LruMap};
 
 use polkadot_primitives::runtime_api::ParachainHost;
 use sc_authority_discovery::Service as AuthorityDiscoveryService;
@@ -344,7 +344,7 @@ where
 		.span_per_active_leaf(Default::default())
 		.active_leaves(Default::default())
 		.supports_parachains(runtime_api_client)
-		.known_leaves(LruCache::new(KNOWN_LEAVES_CACHE_SIZE))
+		.known_leaves(LruMap::new(ByLength::new(KNOWN_LEAVES_CACHE_SIZE)))
 		.metrics(metrics)
 		.spawner(spawner);
 

polkadot/node/subsystem-util/Cargo.toml

@@ -19,7 +19,7 @@ thiserror = "1.0.31"
 fatality = "0.0.6"
 gum = { package = "tracing-gum", path = "../gum" }
 derive_more = "0.99.17"
-lru = "0.11.0"
+schnellru = "0.2.1"
 
 polkadot-node-subsystem = { path = "../subsystem" }
 polkadot-node-jaeger = { path = "../jaeger" }

polkadot/node/subsystem-util/src/runtime/mod.rs

@@ -16,9 +16,7 @@
 
 //! Convenient interface to runtime information.
 
-use std::num::NonZeroUsize;
+use schnellru::{ByLength, LruMap};
-
-use lru::LruCache;
 
 use parity_scale_codec::Encode;
 use sp_application_crypto::AppCrypto;
@@ -58,7 +56,7 @@ pub struct Config {
 	pub keystore: Option<KeystorePtr>,
 
 	/// How many sessions should we keep in the cache?
-	pub session_cache_lru_size: NonZeroUsize,
+	pub session_cache_lru_size: u32,
 }
 
 /// Caching of session info.
@@ -69,10 +67,10 @@ pub struct RuntimeInfo {
 	///
 	/// We query this up to a 100 times per block, so caching it here without roundtrips over the
 	/// overseer seems sensible.
-	session_index_cache: LruCache<Hash, SessionIndex>,
+	session_index_cache: LruMap<Hash, SessionIndex>,
 
 	/// Look up cached sessions by `SessionIndex`.
-	session_info_cache: LruCache<SessionIndex, ExtendedSessionInfo>,
+	session_info_cache: LruMap<SessionIndex, ExtendedSessionInfo>,
 
 	/// Key store for determining whether we are a validator and what `ValidatorIndex` we have.
 	keystore: Option<KeystorePtr>,
@@ -101,7 +99,7 @@ impl Default for Config {
 		Self {
 			keystore: None,
 			// Usually we need to cache the current and the last session.
-			session_cache_lru_size: NonZeroUsize::new(2).expect("2 is larger than 0; qed"),
+			session_cache_lru_size: 2,
 		}
 	}
 }
@@ -115,11 +113,8 @@ impl RuntimeInfo {
 	/// Create with more elaborate configuration options.
 	pub fn new_with_config(cfg: Config) -> Self {
 		Self {
-			session_index_cache: LruCache::new(
+			session_index_cache: LruMap::new(ByLength::new(cfg.session_cache_lru_size.max(10))),
-				cfg.session_cache_lru_size
+			session_info_cache: LruMap::new(ByLength::new(cfg.session_cache_lru_size)),
-					.max(NonZeroUsize::new(10).expect("10 is larger than 0; qed")),
-			),
-			session_info_cache: LruCache::new(cfg.session_cache_lru_size),
 			keystore: cfg.keystore,
 		}
 	}
@@ -139,7 +134,7 @@ impl RuntimeInfo {
 			None => {
 				let index =
 					recv_runtime(request_session_index_for_child(parent, sender).await).await?;
-				self.session_index_cache.put(parent, index);
+				self.session_index_cache.insert(parent, index);
 				Ok(index)
 			},
 		}
@@ -172,7 +167,7 @@ impl RuntimeInfo {
 	where
 		Sender: SubsystemSender<RuntimeApiMessage>,
 	{
-		if !self.session_info_cache.contains(&session_index) {
+		if self.session_info_cache.get(&session_index).is_none() {
 			let session_info =
 				recv_runtime(request_session_info(parent, session_index, sender).await)
 					.await?
@@ -181,7 +176,7 @@ impl RuntimeInfo {
 
 			let full_info = ExtendedSessionInfo { session_info, validator_info };
 
-			self.session_info_cache.put(session_index, full_info);
+			self.session_info_cache.insert(session_index, full_info);
 		}
 		Ok(self
 			.session_info_cache

polkadot/roadmap/implementers-guide/src/node/availability/availability-recovery.md

@@ -30,7 +30,7 @@ struct State {
     /// A recent block hash for which state should be available.
     live_block_hash: Hash,
     // An LRU cache of recently recovered data.
-    availability_lru: LruCache<CandidateHash, Result<AvailableData, RecoveryError>>,
+    availability_lru: LruMap<CandidateHash, Result<AvailableData, RecoveryError>>,
 }
 
 /// This is a future, which concludes either when a response is received from the recovery tasks,

polkadot/roadmap/implementers-guide/src/node/disputes/dispute-coordinator.md

@@ -678,7 +678,7 @@ struct State {
   // It can be a `Vec` if the need to track more arises.
   error: Option<SessionsUnavailable>,
   /// Latest relay blocks that have been successfully scraped.
-  last_scraped_blocks: LruCache<Hash, ()>,
+  last_scraped_blocks: LruMap<Hash, ()>,
 }
 ```