Add cache to test

Cargo.lock

@@ -3556,6 +3556,7 @@ dependencies = [
  "rand 0.8.5",
  "sc-client-api",
  "scale-info",
+ "sp-api",
  "sp-core",
  "sp-externalities",
  "sp-inherents",

cumulus/pallets/parachain-system/Cargo.toml

@@ -20,6 +20,7 @@ frame-system = { path = "../../../substrate/frame/system", default-features = fa
 sp-core = { path = "../../../substrate/primitives/core", default-features = false}
 sp-externalities = { path = "../../../substrate/primitives/externalities", default-features = false}
 sp-inherents = { path = "../../../substrate/primitives/inherents", default-features = false}
+sp-api = { path = "../../../substrate/primitives/api", default-features = false}
 sp-io = { path = "../../../substrate/primitives/io", default-features = false}
 sp-runtime = { path = "../../../substrate/primitives/runtime", default-features = false}
 sp-state-machine = { path = "../../../substrate/primitives/state-machine", default-features = false}

cumulus/pallets/parachain-system/src/validate_block/implementation.rs

@@ -93,6 +93,7 @@ where
 	B::Extrinsic: ExtrinsicCall,
 	<B::Extrinsic as Extrinsic>::Call: IsSubType<crate::Call<PSC>>,
 {
+	sp_api::init_runtime_logger();
 	let block_data = codec::decode_from_bytes::<ParachainBlockData<B>>(block_data)
 		.expect("Invalid parachain block data");
 

cumulus/pallets/parachain-system/src/validate_block/tests.rs

@@ -31,8 +31,7 @@ use sp_trie::TrieRecorderProvider;
 use std::{env, process::Command};
 use trie_standardmap::{Alphabet, StandardMap, ValueMode};
 
-use crate::validate_block::trie_recorder::RecorderProvider;
-use crate::validate_block::MemoryOptimizedValidationParams;
+use crate::validate_block::{trie_recorder::RecorderProvider, MemoryOptimizedValidationParams};
 
 fn call_validate_block_encoded_header(
 	parent_head: Header,
@@ -326,32 +325,46 @@ fn create_trie() -> (MemoryDB, TrieHash<Layout>, Vec<(Vec<u8>, Vec<u8>)>) {
 	(db, root, x)
 }
 use rand::Rng;
+use sp_trie::cache::{CacheSize, SharedTrieCache};
 #[test]
 fn recorder_does_its_thing() {
+	sp_tracing::try_init_simple();
 	let (db, root, values) = create_trie();
 
 	let mut rng = rand::thread_rng();
-	for _ in 1..100 {
-		let reference_recorder = Recorder::default();
-		let recorder_under_test: RecorderProvider<sp_core::Blake2Hasher> = RecorderProvider::new();
+	for _ in 1..2 {
+		let mut reference_recorder = Recorder::default();
+		let recorder_for_test: RecorderProvider<sp_core::Blake2Hasher> = RecorderProvider::new();
+		let reference_cache: SharedTrieCache<sp_core::Blake2Hasher> =
+			SharedTrieCache::new(CacheSize::new(1024 * 5));
+		let cache_for_test: SharedTrieCache<sp_core::Blake2Hasher> =
+			SharedTrieCache::new(CacheSize::new(1024 * 5));
 		{
+			let mut local_cache = cache_for_test.local_cache();
+			let mut trie_cache_for_reference = local_cache.as_trie_db_cache(root);
 			let mut reference_trie_recorder = reference_recorder.as_trie_recorder(root);
 			let reference_trie = TrieDBBuilder::<Layout>::new(&db, &root)
 				.with_recorder(&mut reference_trie_recorder)
+				.with_cache(&mut trie_cache_for_reference)
 				.build();
 
-			let mut trie_recorder_under_test = recorder_under_test.as_trie_recorder(root);
+			let mut local_cache_for_test = cache_for_test.local_cache();
+			let mut trie_cache_for_test = local_cache_for_test.as_trie_db_cache(root);
+			let mut trie_recorder_under_test = recorder_for_test.as_trie_recorder(root);
 			let test_trie = TrieDBBuilder::<Layout>::new(&db, &root)
 				.with_recorder(&mut trie_recorder_under_test)
+				.with_cache(&mut trie_cache_for_test)
 				.build();
 
-			for _ in 0..100 {
+			log::info!("just get");
+			for _ in 0..10 {
 				let index: usize = rng.gen_range(0..values.len());
 				test_trie.get(&values[index].0).unwrap().unwrap();
 				reference_trie.get(&values[index].0).unwrap().unwrap();
 			}
 
-			for _ in 0..100 {
+			log::info!("hash access");
+			for _ in 0..10 {
 				let index: usize = rng.gen_range(0..values.len());
 				test_trie.get_hash(&values[index].0);
 				reference_trie.get_hash(&values[index].0);
@@ -359,7 +372,7 @@ fn recorder_does_its_thing() {
 		}
 		assert_eq!(
 			reference_recorder.estimate_encoded_size(),
-			recorder_under_test.estimate_encoded_size()
+			recorder_for_test.estimate_encoded_size()
 		);
 	}
 }

cumulus/pallets/parachain-system/src/validate_block/trie_recorder.rs

@@ -21,8 +21,7 @@ use codec::Encode;
 
 use sp_std::{
 	cell::{RefCell, RefMut},
-	collections::btree_map::BTreeMap,
-	collections::btree_set::BTreeSet,
+	collections::{btree_map::BTreeMap, btree_set::BTreeSet},
 	sync::Arc,
 };
 use sp_trie::{NodeCodec, StorageProof};
@@ -39,16 +38,18 @@ impl<'a, H: trie_db::Hasher> trie_db::TrieRecorder<H::Out> for SizeRecorder<'a,
 	fn record<'b>(&mut self, access: TrieAccess<'b, H::Out>) {
 		let mut encoded_size_update = 0;
 		match access {
-			TrieAccess::NodeOwned { hash, node_owned } => {
+			TrieAccess::NodeOwned { hash, node_owned } =>
 				if !self.seen_nodes.get(&hash).is_some() {
 					let node = node_owned.to_encoded::<NodeCodec<H>>();
+					log::info!(target: "skunert", "TrieAccess::NodeOwned");
 					encoded_size_update += node.encoded_size();
 					self.seen_nodes.insert(hash);
-				}
-			},
+				},
 			TrieAccess::EncodedNode { hash, encoded_node } => {
 				if !self.seen_nodes.get(&hash).is_some() {
 					let node = encoded_node.into_owned();
+
+					log::info!(target: "skunert", "TrieAccess::EncodedNode");
 					encoded_size_update += node.encoded_size();
 					self.seen_nodes.insert(hash);
 				}
@@ -56,7 +57,7 @@ impl<'a, H: trie_db::Hasher> trie_db::TrieRecorder<H::Out> for SizeRecorder<'a,
 			TrieAccess::Value { hash, value, full_key } => {
 				if !self.seen_nodes.get(&hash).is_some() {
 					let value = value.into_owned();
-
+					log::info!(target: "skunert", "TrieAccess::Value");
 					encoded_size_update += value.encoded_size();
 					self.seen_nodes.insert(hash);
 				}