pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-29 17:17:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

deps: replace lru with schnellru (#1217)

Browse Source 
* deps: replace lru with schnellru

* bring the peace to the galaxy
This commit is contained in:
ordian
2023-08-28 19:04:11 +02:00
committed by GitHub
parent 7125f65fe6
commit c168a77e26
32 changed files with 207 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files
polkadot/node/core/runtime-api/src/cache.rs
+107 -110
View File
@@ -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) {
Some(cap) => cap,
None => panic!("lru capacity must be non-zero"),
};
const DEFAULT_CACHE_CAP: u32 = 128;
pub(crate) struct RequestResultCache {
authorities: LruCache<Hash, Vec<AuthorityDiscoveryId>>,
validators: LruCache<Hash, Vec<ValidatorId>>,
validator_groups: LruCache<Hash, (Vec<Vec<ValidatorIndex>>, GroupRotationInfo)>,
availability_cores: LruCache<Hash, Vec<CoreState>>,
authorities: LruMap<Hash, Vec<AuthorityDiscoveryId>>,
validators: LruMap<Hash, Vec<ValidatorId>>,
validator_groups: LruMap<Hash, (Vec<Vec<ValidatorIndex>>, GroupRotationInfo)>,
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)>>,
check_validation_outputs: LruCache<(Hash, ParaId, CandidateCommitments), bool>,
session_index_for_child: LruCache<Hash, SessionIndex>,
validation_code: LruCache<(Hash, ParaId, OccupiedCoreAssumption), Option<ValidationCode>>,
validation_code_by_hash: LruCache<ValidationCodeHash, Option<ValidationCode>>,
candidate_pending_availability: LruCache<(Hash, ParaId), Option<CommittedCandidateReceipt>>,
candidate_events: LruCache<Hash, Vec<CandidateEvent>>,
session_executor_params: LruCache<SessionIndex, Option<ExecutorParams>>,
session_info: LruCache<SessionIndex, SessionInfo>,
dmq_contents: LruCache<(Hash, ParaId), Vec<InboundDownwardMessage<BlockNumber>>>,
LruMap<(ParaId, Hash), Option<(PersistedValidationData, ValidationCodeHash)>>,
check_validation_outputs: LruMap<(Hash, ParaId, CandidateCommitments), bool>,
session_index_for_child: LruMap<Hash, SessionIndex>,
validation_code: LruMap<(Hash, ParaId, OccupiedCoreAssumption), Option<ValidationCode>>,
validation_code_by_hash: LruMap<ValidationCodeHash, Option<ValidationCode>>,
candidate_pending_availability: LruMap<(Hash, ParaId), Option<CommittedCandidateReceipt>>,
candidate_events: LruMap<Hash, Vec<CandidateEvent>>,
session_executor_params: LruMap<SessionIndex, Option<ExecutorParams>>,
session_info: LruMap<SessionIndex, SessionInfo>,
dmq_contents: LruMap<(Hash, ParaId), Vec<InboundDownwardMessage<BlockNumber>>>,
inbound_hrmp_channels_contents:
LruCache<(Hash, ParaId), BTreeMap<ParaId, Vec<InboundHrmpMessage<BlockNumber>>>>,
current_babe_epoch: LruCache<Hash, Epoch>,
on_chain_votes: LruCache<Hash, Option<ScrapedOnChainVotes>>,
pvfs_require_precheck: LruCache<Hash, Vec<ValidationCodeHash>>,
LruMap<(Hash, ParaId), BTreeMap<ParaId, Vec<InboundHrmpMessage<BlockNumber>>>>,
current_babe_epoch: LruMap<Hash, Epoch>,
on_chain_votes: LruMap<Hash, Option<ScrapedOnChainVotes>>,
pvfs_require_precheck: LruMap<Hash, Vec<ValidationCodeHash>>,
validation_code_hash:
LruCache<(Hash, ParaId, OccupiedCoreAssumption), Option<ValidationCodeHash>>,
version: LruCache<Hash, u32>,
disputes: LruCache<Hash, Vec<(SessionIndex, CandidateHash, DisputeState<BlockNumber>)>>,
LruMap<(Hash, ParaId, OccupiedCoreAssumption), Option<ValidationCodeHash>>,
version: LruMap<Hash, u32>,
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_async_backing_params: LruCache<Hash, vstaging::AsyncBackingParams>,
staging_para_backing_state: LruMap<(Hash, ParaId), Option<vstaging::BackingState>>,
staging_async_backing_params: LruMap<Hash, vstaging::AsyncBackingParams>,
}
impl Default for RequestResultCache {
fn default() -> Self {
Self {
authorities: LruCache::new(DEFAULT_CACHE_CAP),
validators: LruCache::new(DEFAULT_CACHE_CAP),
validator_groups: LruCache::new(DEFAULT_CACHE_CAP),
availability_cores: LruCache::new(DEFAULT_CACHE_CAP),
persisted_validation_data: LruCache::new(DEFAULT_CACHE_CAP),
assumed_validation_data: LruCache::new(DEFAULT_CACHE_CAP),
check_validation_outputs: LruCache::new(DEFAULT_CACHE_CAP),
session_index_for_child: LruCache::new(DEFAULT_CACHE_CAP),
validation_code: LruCache::new(DEFAULT_CACHE_CAP),
validation_code_by_hash: LruCache::new(DEFAULT_CACHE_CAP),
candidate_pending_availability: LruCache::new(DEFAULT_CACHE_CAP),
candidate_events: LruCache::new(DEFAULT_CACHE_CAP),
session_executor_params: LruCache::new(DEFAULT_CACHE_CAP),
session_info: LruCache::new(DEFAULT_CACHE_CAP),
dmq_contents: LruCache::new(DEFAULT_CACHE_CAP),
inbound_hrmp_channels_contents: LruCache::new(DEFAULT_CACHE_CAP),
current_babe_epoch: LruCache::new(DEFAULT_CACHE_CAP),
on_chain_votes: LruCache::new(DEFAULT_CACHE_CAP),
pvfs_require_precheck: LruCache::new(DEFAULT_CACHE_CAP),
validation_code_hash: LruCache::new(DEFAULT_CACHE_CAP),
version: LruCache::new(DEFAULT_CACHE_CAP),
disputes: LruCache::new(DEFAULT_CACHE_CAP),
unapplied_slashes: LruCache::new(DEFAULT_CACHE_CAP),
key_ownership_proof: LruCache::new(DEFAULT_CACHE_CAP),
authorities: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
validators: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
validator_groups: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
availability_cores: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
persisted_validation_data: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
assumed_validation_data: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
check_validation_outputs: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
session_index_for_child: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
validation_code: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
validation_code_by_hash: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
candidate_pending_availability: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
candidate_events: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
session_executor_params: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
session_info: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
dmq_contents: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
inbound_hrmp_channels_contents: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
current_babe_epoch: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
on_chain_votes: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
pvfs_require_precheck: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
validation_code_hash: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
version: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
disputes: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
unapplied_slashes: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
key_ownership_proof: LruMap::new(ByLength::new(DEFAULT_CACHE_CAP)),
staging_para_backing_state: LruCache::new(DEFAULT_CACHE_CAP),
staging_async_backing_params: LruCache::new(DEFAULT_CACHE_CAP),
staging_para_backing_state: LruMap::new(ByLength::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);
}
}