Introduce trie level cache and remove state cache (#11407)

* trie state cache * Also cache missing access on read. * fix comp * bis * fix * use has_lru * remove local storage cache on size 0. * No cache. * local cache only * trie cache and local cache * storage cache (with local) * trie cache no local cache * Add state access benchmark * Remove warnings etc * Add trie cache benchmark * No extra "clone" required * Change benchmark to use multiple blocks * Use patches * Integrate shitty implementation * More stuff * Revert "Merge branch 'master' into trie_state_cache" This reverts commit 947cd8e6d43fced10e21b76d5b92ffa57b57c318, reversing changes made to 29ff036463. * Improve benchmark * Adapt to latest changes * Adapt to changes in trie * Add a test that uses iterator * Start fixing it * Remove obsolete file * Make it compile * Start rewriting the trie node cache * More work on the cache * More docs and code etc * Make data cache an optional * Tests * Remove debug stuff * Recorder * Some docs and a simple test for the recorder * Compile fixes * Make it compile * More fixes * More fixes * Fix fix fix * Make sure cache and recorder work together for basic stuff * Test that data caching and recording works * Test `TrieDBMut` with caching * Try something * Fixes, fixes, fixes * Forward the recorder * Make it compile * Use recorder in more places * Switch to new `with_optional_recorder` fn * Refactor and cleanups * Move `ProvingBackend` tests * Simplify * Move over all functionality to the essence * Fix compilation * Implement estimate encoded size for StorageProof * Start using the `cache` everywhere * Use the cache everywhere * Fix compilation * Fix tests * Adds `TrieBackendBuilder` and enhances the tests * Ensure that recorder drain checks that values are found as expected * Switch over to `TrieBackendBuilder` * Start fixing the problem with child tries and recording * Fix recording of child tries * Make it compile * Overwrite `storage_hash` in `TrieBackend` * Add `storage_cache` to the benchmarks * Fix `no_std` build * Speed up cache lookup * Extend the state access benchmark to also hash a runtime * Fix build * Fix compilation * Rewrite value cache * Add lru cache * Ensure that the cache lru works * Value cache should not be optional * Add support for keeping the shared node cache in its bounds * Make the cache configurable * Check that the cache respects the bounds * Adds a new test * Fixes * Docs and some renamings * More docs * Start using the new recorder * Fix more code * Take `self` argument * Remove warnings * Fix benchmark * Fix accounting * Rip off the state cache * Start fixing fallout after removing the state cache * Make it compile after trie changes * Fix test * Add some logging * Some docs * Some fixups and clean ups * Fix benchmark * Remove unneeded file * Use git for patching * Make CI happy * Update primitives/trie/Cargo.toml Co-authored-by: Koute <koute@users.noreply.github.com> * Update primitives/state-machine/src/trie_backend.rs Co-authored-by: cheme <emericchevalier.pro@gmail.com> * Introduce new `AsTrieBackend` trait * Make the LocalTrieCache not clonable * Make it work in no_std and add docs * Remove duplicate dependency * Switch to ahash for better performance * Speedup value cache merge * Output errors on underflow * Ensure the internal LRU map doesn't grow too much * Use const fn to calculate the value cache element size * Remove cache configuration * Fix * Clear the cache in between for more testing * Try to come up with a failing test case * Make the test fail * Fix the child trie recording * Make everything compile after the changes to trie * Adapt to latest trie-db changes * Fix on stable * Update primitives/trie/src/cache.rs Co-authored-by: cheme <emericchevalier.pro@gmail.com> * Fix wrong merge * Docs * Fix warnings * Cargo.lock * Bump pin-project * Fix warnings * Switch to released crate version * More fixes * Make clippy and rustdocs happy * More clippy * Print error when using deprecated `--state-cache-size` * 🤦 * Fixes * Fix storage_hash linkings * Update client/rpc/src/dev/mod.rs Co-authored-by: Arkadiy Paronyan <arkady.paronyan@gmail.com> * Review feedback * encode bound * Rework the shared value cache Instead of using a `u64` to represent the key we now use an `Arc<[u8]>`. This arc is also stored in some extra `HashSet`. We store the key are in an extra `HashSet` to de-duplicate the keys accross different storage roots. When the latest key usage is dropped in the lru, we also remove the key from the `HashSet`. * Improve of the cache by merging the old and new solution * FMT * Please stop coming back all the time :crying: * Update primitives/trie/src/cache/shared_cache.rs Co-authored-by: Arkadiy Paronyan <arkady.paronyan@gmail.com> * Fixes * Make clippy happy * Ensure we don't deadlock * Only use one lock to simplify the code * Do not depend on `Hasher` * Fix tests * FMT * Clippy 🤦 Co-authored-by: cheme <emericchevalier.pro@gmail.com> Co-authored-by: Koute <koute@users.noreply.github.com> Co-authored-by: Arkadiy Paronyan <arkady.paronyan@gmail.com>
2026-06-16 14:21:10 +00:00 · 2022-08-18 20:59:22 +02:00
parent d46f6f0d34
commit 73d9ae3284
55 changed files with 3977 additions and 1344 deletions
@@ -18,23 +18,32 @@
 //! Trie-based state machine backend essence used to read values
 //! from storage.

-use crate::{backend::Consolidate, debug, warn, StorageKey, StorageValue};
-use codec::Encode;
+use crate::{
+	backend::Consolidate, debug, trie_backend::AsLocalTrieCache, warn, StorageKey, StorageValue,
+};
+use codec::Codec;
 use hash_db::{self, AsHashDB, HashDB, HashDBRef, Hasher, Prefix};
 #[cfg(feature = "std")]
 use parking_lot::RwLock;
 use sp_core::storage::{ChildInfo, ChildType, StateVersion};
+#[cfg(not(feature = "std"))]
+use sp_std::marker::PhantomData;
 use sp_std::{boxed::Box, vec::Vec};
+#[cfg(feature = "std")]
+use sp_trie::recorder::Recorder;
 use sp_trie::{
-	child_delta_trie_root, delta_trie_root, empty_child_trie_root, read_child_trie_value,
-	read_trie_value,
-	trie_types::{TrieDB, TrieError},
-	DBValue, KeySpacedDB, LayoutV1 as Layout, Trie, TrieDBIterator, TrieDBKeyIterator,
+	child_delta_trie_root, delta_trie_root, empty_child_trie_root, read_child_trie_hash,
+	read_child_trie_value, read_trie_value,
+	trie_types::{TrieDBBuilder, TrieError},
+	DBValue, KeySpacedDB, NodeCodec, Trie, TrieCache, TrieDBIterator, TrieDBKeyIterator,
+	TrieRecorder,
 };
 #[cfg(feature = "std")]
-use std::collections::HashMap;
-#[cfg(feature = "std")]
-use std::sync::Arc;
+use std::{collections::HashMap, sync::Arc};
+
+// In this module, we only use layout for read operation and empty root,
+// where V1 and V0 are equivalent.
+use sp_trie::LayoutV1 as Layout;

 #[cfg(not(feature = "std"))]
 macro_rules! format {
@@ -68,18 +77,21 @@ impl<H> Cache<H> {
 }

 /// Patricia trie-based pairs storage essence.
-pub struct TrieBackendEssence<S: TrieBackendStorage<H>, H: Hasher> {
+pub struct TrieBackendEssence<S: TrieBackendStorage<H>, H: Hasher, C> {
 	storage: S,
 	root: H::Out,
 	empty: H::Out,
 	#[cfg(feature = "std")]
 	pub(crate) cache: Arc<RwLock<Cache<H::Out>>>,
+	#[cfg(feature = "std")]
+	pub(crate) trie_node_cache: Option<C>,
+	#[cfg(feature = "std")]
+	pub(crate) recorder: Option<Recorder<H>>,
+	#[cfg(not(feature = "std"))]
+	_phantom: PhantomData<C>,
 }

-impl<S: TrieBackendStorage<H>, H: Hasher> TrieBackendEssence<S, H>
-where
-	H::Out: Encode,
-{
+impl<S: TrieBackendStorage<H>, H: Hasher, C> TrieBackendEssence<S, H, C> {
 	/// Create new trie-based backend.
 	pub fn new(storage: S, root: H::Out) -> Self {
 		TrieBackendEssence {
@@ -88,6 +100,30 @@ where
 			empty: H::hash(&[0u8]),
 			#[cfg(feature = "std")]
 			cache: Arc::new(RwLock::new(Cache::new())),
+			#[cfg(feature = "std")]
+			trie_node_cache: None,
+			#[cfg(feature = "std")]
+			recorder: None,
+			#[cfg(not(feature = "std"))]
+			_phantom: PhantomData,
+		}
+	}
+
+	/// Create new trie-based backend.
+	#[cfg(feature = "std")]
+	pub fn new_with_cache_and_recorder(
+		storage: S,
+		root: H::Out,
+		cache: Option<C>,
+		recorder: Option<Recorder<H>>,
+	) -> Self {
+		TrieBackendEssence {
+			storage,
+			root,
+			empty: H::hash(&[0u8]),
+			cache: Arc::new(RwLock::new(Cache::new())),
+			trie_node_cache: cache,
+			recorder,
 		}
 	}

@@ -96,6 +132,11 @@ where
 		&self.storage
 	}

+	/// Get backend storage mutable reference.
+	pub fn backend_storage_mut(&mut self) -> &mut S {
+		&mut self.storage
+	}
+
 	/// Get trie root.
 	pub fn root(&self) -> &H::Out {
 		&self.root
@@ -120,7 +161,97 @@ where
 	pub fn into_storage(self) -> S {
 		self.storage
 	}
+}

+impl<S: TrieBackendStorage<H>, H: Hasher, C: AsLocalTrieCache<H>> TrieBackendEssence<S, H, C> {
+	/// Call the given closure passing it the recorder and the cache.
+	///
+	/// If the given `storage_root` is `None`, `self.root` will be used.
+	#[cfg(feature = "std")]
+	fn with_recorder_and_cache<R>(
+		&self,
+		storage_root: Option<H::Out>,
+		callback: impl FnOnce(
+			Option<&mut dyn TrieRecorder<H::Out>>,
+			Option<&mut dyn TrieCache<NodeCodec<H>>>,
+		) -> R,
+	) -> R {
+		let storage_root = storage_root.unwrap_or_else(|| self.root);
+		let mut recorder = self.recorder.as_ref().map(|r| r.as_trie_recorder());
+		let recorder = recorder.as_mut().map(|r| r as _);
+
+		let mut cache = self
+			.trie_node_cache
+			.as_ref()
+			.map(|c| c.as_local_trie_cache().as_trie_db_cache(storage_root));
+		let cache = cache.as_mut().map(|c| c as _);
+
+		callback(recorder, cache)
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn with_recorder_and_cache<R>(
+		&self,
+		_: Option<H::Out>,
+		callback: impl FnOnce(
+			Option<&mut dyn TrieRecorder<H::Out>>,
+			Option<&mut dyn TrieCache<NodeCodec<H>>>,
+		) -> R,
+	) -> R {
+		callback(None, None)
+	}
+
+	/// Call the given closure passing it the recorder and the cache.
+	///
+	/// This function must only be used when the operation in `callback` is
+	/// calculating a `storage_root`. It is expected that `callback` returns
+	/// the new storage root. This is required to register the changes in the cache
+	/// for the correct storage root.
+	#[cfg(feature = "std")]
+	fn with_recorder_and_cache_for_storage_root<R>(
+		&self,
+		callback: impl FnOnce(
+			Option<&mut dyn TrieRecorder<H::Out>>,
+			Option<&mut dyn TrieCache<NodeCodec<H>>>,
+		) -> (Option<H::Out>, R),
+	) -> R {
+		let mut recorder = self.recorder.as_ref().map(|r| r.as_trie_recorder());
+		let recorder = recorder.as_mut().map(|r| r as _);
+
+		let result = if let Some(local_cache) = self.trie_node_cache.as_ref() {
+			let mut cache = local_cache.as_local_trie_cache().as_trie_db_mut_cache();
+
+			let (new_root, r) = callback(recorder, Some(&mut cache));
+
+			if let Some(new_root) = new_root {
+				cache.merge_into(local_cache.as_local_trie_cache(), new_root);
+			}
+
+			r
+		} else {
+			callback(recorder, None).1
+		};
+
+		result
+	}
+
+	#[cfg(not(feature = "std"))]
+	fn with_recorder_and_cache_for_storage_root<R>(
+		&self,
+		callback: impl FnOnce(
+			Option<&mut dyn TrieRecorder<H::Out>>,
+			Option<&mut dyn TrieCache<NodeCodec<H>>>,
+		) -> (Option<H::Out>, R),
+	) -> R {
+		callback(None, None).1
+	}
+}
+
+impl<S: TrieBackendStorage<H>, H: Hasher, C: AsLocalTrieCache<H> + Send + Sync>
+	TrieBackendEssence<S, H, C>
+where
+	H::Out: Codec + Ord,
+{
 	/// Return the next key in the trie i.e. the minimum key that is strictly superior to `key` in
 	/// lexicographic order.
 	pub fn next_storage_key(&self, key: &[u8]) -> Result<Option<StorageKey>> {
@@ -184,39 +315,82 @@ where
 			dyn_eph = self;
 		}

-		let trie =
-			TrieDB::<H>::new(dyn_eph, root).map_err(|e| format!("TrieDB creation error: {}", e))?;
-		let mut iter = trie.key_iter().map_err(|e| format!("TrieDB iteration error: {}", e))?;
+		self.with_recorder_and_cache(Some(*root), |recorder, cache| {
+			let trie = TrieDBBuilder::<H>::new(dyn_eph, root)
+				.with_optional_recorder(recorder)
+				.with_optional_cache(cache)
+				.build();

-		// The key just after the one given in input, basically `key++0`.
-		// Note: We are sure this is the next key if:
-		// * size of key has no limit (i.e. we can always add 0 to the path),
-		// * and no keys can be inserted between `key` and `key++0` (this is ensured by sp-io).
-		let mut potential_next_key = Vec::with_capacity(key.len() + 1);
-		potential_next_key.extend_from_slice(key);
-		potential_next_key.push(0);
+			let mut iter = trie.key_iter().map_err(|e| format!("TrieDB iteration error: {}", e))?;

-		iter.seek(&potential_next_key)
-			.map_err(|e| format!("TrieDB iterator seek error: {}", e))?;
+			// The key just after the one given in input, basically `key++0`.
+			// Note: We are sure this is the next key if:
+			// * size of key has no limit (i.e. we can always add 0 to the path),
+			// * and no keys can be inserted between `key` and `key++0` (this is ensured by sp-io).
+			let mut potential_next_key = Vec::with_capacity(key.len() + 1);
+			potential_next_key.extend_from_slice(key);
+			potential_next_key.push(0);

-		let next_element = iter.next();
+			iter.seek(&potential_next_key)
+				.map_err(|e| format!("TrieDB iterator seek error: {}", e))?;

-		let next_key = if let Some(next_element) = next_element {
-			let next_key =
-				next_element.map_err(|e| format!("TrieDB iterator next error: {}", e))?;
-			Some(next_key)
-		} else {
-			None
-		};
+			let next_element = iter.next();

-		Ok(next_key)
+			let next_key = if let Some(next_element) = next_element {
+				let next_key =
+					next_element.map_err(|e| format!("TrieDB iterator next error: {}", e))?;
+				Some(next_key)
+			} else {
+				None
+			};
+
+			Ok(next_key)
+		})
+	}
+
+	/// Returns the hash value
+	pub fn storage_hash(&self, key: &[u8]) -> Result<Option<H::Out>> {
+		let map_e = |e| format!("Trie lookup error: {}", e);
+
+		self.with_recorder_and_cache(None, |recorder, cache| {
+			TrieDBBuilder::new(self, &self.root)
+				.with_optional_cache(cache)
+				.with_optional_recorder(recorder)
+				.build()
+				.get_hash(key)
+				.map_err(map_e)
+		})
 	}

 	/// Get the value of storage at given key.
 	pub fn storage(&self, key: &[u8]) -> Result<Option<StorageValue>> {
 		let map_e = |e| format!("Trie lookup error: {}", e);

-		read_trie_value::<Layout<H>, _>(self, &self.root, key).map_err(map_e)
+		self.with_recorder_and_cache(None, |recorder, cache| {
+			read_trie_value::<Layout<H>, _>(self, &self.root, key, recorder, cache).map_err(map_e)
+		})
+	}
+
+	/// Returns the hash value
+	pub fn child_storage_hash(&self, child_info: &ChildInfo, key: &[u8]) -> Result<Option<H::Out>> {
+		let child_root = match self.child_root(child_info)? {
+			Some(root) => root,
+			None => return Ok(None),
+		};
+
+		let map_e = |e| format!("Trie lookup error: {}", e);
+
+		self.with_recorder_and_cache(Some(child_root), |recorder, cache| {
+			read_child_trie_hash::<Layout<H>, _>(
+				child_info.keyspace(),
+				self,
+				&child_root,
+				key,
+				recorder,
+				cache,
+			)
+			.map_err(map_e)
+		})
 	}

 	/// Get the value of child storage at given key.
@@ -225,15 +399,24 @@ where
 		child_info: &ChildInfo,
 		key: &[u8],
 	) -> Result<Option<StorageValue>> {
-		let root = match self.child_root(child_info)? {
+		let child_root = match self.child_root(child_info)? {
 			Some(root) => root,
 			None => return Ok(None),
 		};

 		let map_e = |e| format!("Trie lookup error: {}", e);

-		read_child_trie_value::<Layout<H>, _>(child_info.keyspace(), self, &root, key)
+		self.with_recorder_and_cache(Some(child_root), |recorder, cache| {
+			read_child_trie_value::<Layout<H>, _>(
+				child_info.keyspace(),
+				self,
+				&child_root,
+				key,
+				recorder,
+				cache,
+			)
 			.map_err(map_e)
+		})
 	}

 	/// Retrieve all entries keys of storage and call `f` for each of those keys.
@@ -338,28 +521,33 @@ where
 		maybe_start_at: Option<&[u8]>,
 	) {
 		let mut iter = move |db| -> sp_std::result::Result<(), Box<TrieError<H::Out>>> {
-			let trie = TrieDB::<H>::new(db, root)?;
-			let prefix = maybe_prefix.unwrap_or(&[]);
-			let iter = match maybe_start_at {
-				Some(start_at) =>
-					TrieDBKeyIterator::new_prefixed_then_seek(&trie, prefix, start_at),
-				None => TrieDBKeyIterator::new_prefixed(&trie, prefix),
-			}?;
+			self.with_recorder_and_cache(Some(*root), |recorder, cache| {
+				let trie = TrieDBBuilder::<H>::new(db, root)
+					.with_optional_recorder(recorder)
+					.with_optional_cache(cache)
+					.build();
+				let prefix = maybe_prefix.unwrap_or(&[]);
+				let iter = match maybe_start_at {
+					Some(start_at) =>
+						TrieDBKeyIterator::new_prefixed_then_seek(&trie, prefix, start_at),
+					None => TrieDBKeyIterator::new_prefixed(&trie, prefix),
+				}?;

-			for x in iter {
-				let key = x?;
+				for x in iter {
+					let key = x?;

-				debug_assert!(maybe_prefix
-					.as_ref()
-					.map(|prefix| key.starts_with(prefix))
-					.unwrap_or(true));
+					debug_assert!(maybe_prefix
+						.as_ref()
+						.map(|prefix| key.starts_with(prefix))
+						.unwrap_or(true));

-				if !f(&key) {
-					break
+					if !f(&key) {
+						break
+					}
 				}
-			}

-			Ok(())
+				Ok(())
+			})
 		};

 		let result = if let Some(child_info) = child_info {
@@ -383,25 +571,30 @@ where
 		allow_missing_nodes: bool,
 	) -> Result<bool> {
 		let mut iter = move |db| -> sp_std::result::Result<bool, Box<TrieError<H::Out>>> {
-			let trie = TrieDB::<H>::new(db, root)?;
+			self.with_recorder_and_cache(Some(*root), |recorder, cache| {
+				let trie = TrieDBBuilder::<H>::new(db, root)
+					.with_optional_recorder(recorder)
+					.with_optional_cache(cache)
+					.build();

-			let prefix = prefix.unwrap_or(&[]);
-			let iterator = if let Some(start_at) = start_at {
-				TrieDBIterator::new_prefixed_then_seek(&trie, prefix, start_at)?
-			} else {
-				TrieDBIterator::new_prefixed(&trie, prefix)?
-			};
-			for x in iterator {
-				let (key, value) = x?;
+				let prefix = prefix.unwrap_or(&[]);
+				let iterator = if let Some(start_at) = start_at {
+					TrieDBIterator::new_prefixed_then_seek(&trie, prefix, start_at)?
+				} else {
+					TrieDBIterator::new_prefixed(&trie, prefix)?
+				};
+				for x in iterator {
+					let (key, value) = x?;

-				debug_assert!(key.starts_with(prefix));
+					debug_assert!(key.starts_with(prefix));

-				if !f(key, value) {
-					return Ok(false)
+					if !f(key, value) {
+						return Ok(false)
+					}
 				}
-			}

-			Ok(true)
+				Ok(true)
+			})
 		};

 		let result = if let Some(child_info) = child_info {
@@ -436,14 +629,20 @@ where
 	/// Returns all `(key, value)` pairs in the trie.
 	pub fn pairs(&self) -> Vec<(StorageKey, StorageValue)> {
 		let collect_all = || -> sp_std::result::Result<_, Box<TrieError<H::Out>>> {
-			let trie = TrieDB::<H>::new(self, &self.root)?;
-			let mut v = Vec::new();
-			for x in trie.iter()? {
-				let (key, value) = x?;
-				v.push((key.to_vec(), value.to_vec()));
-			}
+			self.with_recorder_and_cache(None, |recorder, cache| {
+				let trie = TrieDBBuilder::<H>::new(self, self.root())
+					.with_optional_cache(cache)
+					.with_optional_recorder(recorder)
+					.build();

-			Ok(v)
+				let mut v = Vec::new();
+				for x in trie.iter()? {
+					let (key, value) = x?;
+					v.push((key.to_vec(), value.to_vec()));
+				}
+
+				Ok(v)
+			})
 		};

 		match collect_all() {
@@ -467,27 +666,28 @@ where
 		&self,
 		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
 		state_version: StateVersion,
-	) -> (H::Out, S::Overlay)
-	where
-		H::Out: Ord,
-	{
+	) -> (H::Out, S::Overlay) {
 		let mut write_overlay = S::Overlay::default();
-		let mut root = self.root;

-		{
+		let root = self.with_recorder_and_cache_for_storage_root(|recorder, cache| {
 			let mut eph = Ephemeral::new(self.backend_storage(), &mut write_overlay);
 			let res = match state_version {
-				StateVersion::V0 =>
-					delta_trie_root::<sp_trie::LayoutV0<H>, _, _, _, _, _>(&mut eph, root, delta),
-				StateVersion::V1 =>
-					delta_trie_root::<sp_trie::LayoutV1<H>, _, _, _, _, _>(&mut eph, root, delta),
+				StateVersion::V0 => delta_trie_root::<sp_trie::LayoutV0<H>, _, _, _, _, _>(
+					&mut eph, self.root, delta, recorder, cache,
+				),
+				StateVersion::V1 => delta_trie_root::<sp_trie::LayoutV1<H>, _, _, _, _, _>(
+					&mut eph, self.root, delta, recorder, cache,
+				),
 			};

 			match res {
-				Ok(ret) => root = ret,
-				Err(e) => warn!(target: "trie", "Failed to write to trie: {}", e),
+				Ok(ret) => (Some(ret), ret),
+				Err(e) => {
+					warn!(target: "trie", "Failed to write to trie: {}", e);
+					(None, self.root)
+				},
 			}
-		}
+		});

 		(root, write_overlay)
 	}
@@ -499,15 +699,12 @@ where
 		child_info: &ChildInfo,
 		delta: impl Iterator<Item = (&'a [u8], Option<&'a [u8]>)>,
 		state_version: StateVersion,
-	) -> (H::Out, bool, S::Overlay)
-	where
-		H::Out: Ord,
-	{
+	) -> (H::Out, bool, S::Overlay) {
 		let default_root = match child_info.child_type() {
 			ChildType::ParentKeyId => empty_child_trie_root::<sp_trie::LayoutV1<H>>(),
 		};
 		let mut write_overlay = S::Overlay::default();
-		let mut root = match self.child_root(child_info) {
+		let child_root = match self.child_root(child_info) {
 			Ok(Some(hash)) => hash,
 			Ok(None) => default_root,
 			Err(e) => {
@@ -516,32 +713,39 @@ where
 			},
 		};

-		{
+		let new_child_root = self.with_recorder_and_cache_for_storage_root(|recorder, cache| {
 			let mut eph = Ephemeral::new(self.backend_storage(), &mut write_overlay);
 			match match state_version {
 				StateVersion::V0 =>
 					child_delta_trie_root::<sp_trie::LayoutV0<H>, _, _, _, _, _, _>(
 						child_info.keyspace(),
 						&mut eph,
-						root,
+						child_root,
 						delta,
+						recorder,
+						cache,
 					),
 				StateVersion::V1 =>
 					child_delta_trie_root::<sp_trie::LayoutV1<H>, _, _, _, _, _, _>(
 						child_info.keyspace(),
 						&mut eph,
-						root,
+						child_root,
 						delta,
+						recorder,
+						cache,
 					),
 			} {
-				Ok(ret) => root = ret,
-				Err(e) => warn!(target: "trie", "Failed to write to trie: {}", e),
+				Ok(ret) => (Some(ret), ret),
+				Err(e) => {
+					warn!(target: "trie", "Failed to write to trie: {}", e);
+					(None, child_root)
+				},
 			}
-		}
+		});

-		let is_default = root == default_root;
+		let is_default = new_child_root == default_root;

-		(root, is_default, write_overlay)
+		(new_child_root, is_default, write_overlay)
 	}
 }

@@ -615,6 +819,14 @@ pub trait TrieBackendStorage<H: Hasher>: Send + Sync {
 	fn get(&self, key: &H::Out, prefix: Prefix) -> Result<Option<DBValue>>;
 }

+impl<T: TrieBackendStorage<H>, H: Hasher> TrieBackendStorage<H> for &T {
+	type Overlay = T::Overlay;
+
+	fn get(&self, key: &H::Out, prefix: Prefix) -> Result<Option<DBValue>> {
+		(*self).get(key, prefix)
+	}
+}
+
 // This implementation is used by normal storage trie clients.
 #[cfg(feature = "std")]
 impl<H: Hasher> TrieBackendStorage<H> for Arc<dyn Storage<H>> {
@@ -637,7 +849,9 @@ where
 	}
 }

-impl<S: TrieBackendStorage<H>, H: Hasher> AsHashDB<H, DBValue> for TrieBackendEssence<S, H> {
+impl<S: TrieBackendStorage<H>, H: Hasher, C: AsLocalTrieCache<H> + Send + Sync> AsHashDB<H, DBValue>
+	for TrieBackendEssence<S, H, C>
+{
 	fn as_hash_db<'b>(&'b self) -> &'b (dyn HashDB<H, DBValue> + 'b) {
 		self
 	}
@@ -646,7 +860,9 @@ impl<S: TrieBackendStorage<H>, H: Hasher> AsHashDB<H, DBValue> for TrieBackendEs
 	}
 }

-impl<S: TrieBackendStorage<H>, H: Hasher> HashDB<H, DBValue> for TrieBackendEssence<S, H> {
+impl<S: TrieBackendStorage<H>, H: Hasher, C: AsLocalTrieCache<H> + Send + Sync> HashDB<H, DBValue>
+	for TrieBackendEssence<S, H, C>
+{
 	fn get(&self, key: &H::Out, prefix: Prefix) -> Option<DBValue> {
 		if *key == self.empty {
 			return Some([0u8].to_vec())
@@ -677,7 +893,9 @@ impl<S: TrieBackendStorage<H>, H: Hasher> HashDB<H, DBValue> for TrieBackendEsse
 	}
 }

-impl<S: TrieBackendStorage<H>, H: Hasher> HashDBRef<H, DBValue> for TrieBackendEssence<S, H> {
+impl<S: TrieBackendStorage<H>, H: Hasher, C: AsLocalTrieCache<H> + Send + Sync>
+	HashDBRef<H, DBValue> for TrieBackendEssence<S, H, C>
+{
 	fn get(&self, key: &H::Out, prefix: Prefix) -> Option<DBValue> {
 		HashDB::get(self, key, prefix)
 	}
@@ -692,7 +910,8 @@ mod test {
 	use super::*;
 	use sp_core::{Blake2Hasher, H256};
 	use sp_trie::{
-		trie_types::TrieDBMutV1 as TrieDBMut, KeySpacedDBMut, PrefixedMemoryDB, TrieMut,
+		cache::LocalTrieCache, trie_types::TrieDBMutBuilderV1 as TrieDBMutBuilder, KeySpacedDBMut,
+		PrefixedMemoryDB, TrieMut,
 	};

 	#[test]
@@ -706,7 +925,7 @@ mod test {

 		let mut mdb = PrefixedMemoryDB::<Blake2Hasher>::default();
 		{
-			let mut trie = TrieDBMut::new(&mut mdb, &mut root_1);
+			let mut trie = TrieDBMutBuilder::new(&mut mdb, &mut root_1).build();
 			trie.insert(b"3", &[1]).expect("insert failed");
 			trie.insert(b"4", &[1]).expect("insert failed");
 			trie.insert(b"6", &[1]).expect("insert failed");
@@ -715,18 +934,18 @@ mod test {
 			let mut mdb = KeySpacedDBMut::new(&mut mdb, child_info.keyspace());
 			// reuse of root_1 implicitly assert child trie root is same
 			// as top trie (contents must remain the same).
-			let mut trie = TrieDBMut::new(&mut mdb, &mut root_1);
+			let mut trie = TrieDBMutBuilder::new(&mut mdb, &mut root_1).build();
 			trie.insert(b"3", &[1]).expect("insert failed");
 			trie.insert(b"4", &[1]).expect("insert failed");
 			trie.insert(b"6", &[1]).expect("insert failed");
 		}
 		{
-			let mut trie = TrieDBMut::new(&mut mdb, &mut root_2);
+			let mut trie = TrieDBMutBuilder::new(&mut mdb, &mut root_2).build();
 			trie.insert(child_info.prefixed_storage_key().as_slice(), root_1.as_ref())
 				.expect("insert failed");
 		};

-		let essence_1 = TrieBackendEssence::new(mdb, root_1);
+		let essence_1 = TrieBackendEssence::<_, _, LocalTrieCache<_>>::new(mdb, root_1);

 		assert_eq!(essence_1.next_storage_key(b"2"), Ok(Some(b"3".to_vec())));
 		assert_eq!(essence_1.next_storage_key(b"3"), Ok(Some(b"4".to_vec())));
@@ -734,8 +953,8 @@ mod test {
 		assert_eq!(essence_1.next_storage_key(b"5"), Ok(Some(b"6".to_vec())));
 		assert_eq!(essence_1.next_storage_key(b"6"), Ok(None));

-		let mdb = essence_1.into_storage();
-		let essence_2 = TrieBackendEssence::new(mdb, root_2);
+		let mdb = essence_1.backend_storage().clone();
+		let essence_2 = TrieBackendEssence::<_, _, LocalTrieCache<_>>::new(mdb, root_2);

 		assert_eq!(essence_2.next_child_storage_key(child_info, b"2"), Ok(Some(b"3".to_vec())));
 		assert_eq!(essence_2.next_child_storage_key(child_info, b"3"), Ok(Some(b"4".to_vec())));