From 8d96a71e81eec0f047fa1dc34aa53431845c2fb6 Mon Sep 17 00:00:00 2001 From: thiolliere Date: Mon, 17 Aug 2020 17:55:21 +0200 Subject: [PATCH 1/6] WIP: read child trie and write child trie --- client/db/src/bench.rs | 149 +++++++++++++++--------- primitives/state-machine/src/backend.rs | 10 +- primitives/state-machine/src/ext.rs | 1 + 3 files changed, 104 insertions(+), 56 deletions(-) diff --git a/client/db/src/bench.rs b/client/db/src/bench.rs index c3bed3e24f617..580286f6f561a 100644 --- a/client/db/src/bench.rs +++ b/client/db/src/bench.rs @@ -27,7 +27,9 @@ use sp_trie::{MemoryDB, prefixed_key}; use sp_core::{storage::ChildInfo, hexdisplay::HexDisplay}; use sp_runtime::traits::{Block as BlockT, HashFor}; use sp_runtime::Storage; -use sp_state_machine::{DBValue, backend::Backend as StateBackend, StorageCollection}; +use sp_state_machine::{ + DBValue, backend::Backend as StateBackend, StorageCollection, ChildStorageCollection +}; use kvdb::{KeyValueDB, DBTransaction}; use crate::storage_cache::{CachingState, SharedCache, new_shared_cache}; @@ -93,11 +95,71 @@ pub struct BenchmarkingState { genesis: HashMap, (Vec, i32)>, record: Cell>>, shared_cache: SharedCache, // shared cache is always empty + /// Key tracker for keys in the top trie. key_tracker: RefCell, KeyTracker>>, + /// Key tracker for keys in a child trie. + /// Child trie are identified by their storage key (i.e. `ChildInfo::storage_key()`) + child_key_tracker: RefCell, HashMap, KeyTracker>>>, read_write_tracker: RefCell, whitelist: RefCell>>, } +fn add_read_key_in_key_tracker( + key_tracker: &mut HashMap, KeyTracker>, + read_write_tracker: &mut ReadWriteTracker, + key: &[u8] +) { + let maybe_tracker = key_tracker.get(key); + + let has_been_read = KeyTracker { + has_been_read: true, + has_been_written: false, + }; + + match maybe_tracker { + None => { + key_tracker.insert(key.to_vec(), has_been_read); + read_write_tracker.add_read(); + }, + Some(tracker) => { + if !tracker.has_been_read { + key_tracker.insert(key.to_vec(), has_been_read); + read_write_tracker.add_read(); + } else { + read_write_tracker.add_repeat_read(); + } + } + } +} + +fn add_write_key_in_key_tracker( + key_tracker: &mut HashMap, KeyTracker>, + read_write_tracker: &mut ReadWriteTracker, + key: &[u8] +) { + let maybe_tracker = key_tracker.get(key); + + let has_been_written = KeyTracker { + has_been_read: true, + has_been_written: true, + }; + + match maybe_tracker { + None => { + key_tracker.insert(key.to_vec(), has_been_written); + read_write_tracker.add_write(); + }, + Some(tracker) => { + if !tracker.has_been_written { + key_tracker.insert(key.to_vec(), has_been_written); + read_write_tracker.add_write(); + } else { + read_write_tracker.add_repeat_write(); + } + } + } +} + impl BenchmarkingState { /// Create a new instance that creates a database in a temporary dir. pub fn new(genesis: Storage, _cache_size_mb: Option) -> Result { @@ -114,6 +176,7 @@ impl BenchmarkingState { record: Default::default(), shared_cache: new_shared_cache(0, (1, 10)), key_tracker: Default::default(), + child_key_tracker: Default::default(), read_write_tracker: Default::default(), whitelist: Default::default(), }; @@ -131,7 +194,7 @@ impl BenchmarkingState { ); state.genesis = transaction.clone().drain(); state.genesis_root = root.clone(); - state.commit(root, transaction, Vec::new())?; + state.commit(root, transaction, Vec::new(), Vec::new())?; state.record.take(); Ok(state) } @@ -175,61 +238,34 @@ impl BenchmarkingState { fn add_read_key(&self, key: &[u8]) { log::trace!(target: "benchmark", "Read: {}", HexDisplay::from(&key)); - let mut key_tracker = self.key_tracker.borrow_mut(); let mut read_write_tracker = self.read_write_tracker.borrow_mut(); - - let maybe_tracker = key_tracker.get(key); - - let has_been_read = KeyTracker { - has_been_read: true, - has_been_written: false, - }; - - match maybe_tracker { - None => { - key_tracker.insert(key.to_vec(), has_been_read); - read_write_tracker.add_read(); - }, - Some(tracker) => { - if !tracker.has_been_read { - key_tracker.insert(key.to_vec(), has_been_read); - read_write_tracker.add_read(); - } else { - read_write_tracker.add_repeat_read(); - } - } - } + add_read_key_in_key_tracker(&mut key_tracker, &mut read_write_tracker, key); } fn add_write_key(&self, key: &[u8]) { log::trace!(target: "benchmark", "Write: {}", HexDisplay::from(&key)); - let mut key_tracker = self.key_tracker.borrow_mut(); let mut read_write_tracker = self.read_write_tracker.borrow_mut(); + add_write_key_in_key_tracker(&mut key_tracker, &mut read_write_tracker, key); + } - let maybe_tracker = key_tracker.get(key); - - // If we have written to the key, we also consider that we have read from it. - let has_been_written = KeyTracker { - has_been_read: true, - has_been_written: true, - }; + fn add_read_child_key(&self, child: &[u8], key: &[u8]) { + log::trace!(target: "benchmark", "Read: {}", HexDisplay::from(&key)); + let mut child_key_tracker = self.child_key_tracker.borrow_mut(); + let mut key_tracker = child_key_tracker.entry(child.to_vec()) + .or_insert_with(|| HashMap::new()); + let mut read_write_tracker = self.read_write_tracker.borrow_mut(); + add_read_key_in_key_tracker(&mut key_tracker, &mut read_write_tracker, key); + } - match maybe_tracker { - None => { - key_tracker.insert(key.to_vec(), has_been_written); - read_write_tracker.add_write(); - }, - Some(tracker) => { - if !tracker.has_been_written { - key_tracker.insert(key.to_vec(), has_been_written); - read_write_tracker.add_write(); - } else { - read_write_tracker.add_repeat_write(); - } - } - } + fn add_write_child_key(&self, child: &[u8], key: &[u8]) { + log::trace!(target: "benchmark", "Write: {}", HexDisplay::from(&key)); + let mut child_key_tracker = self.child_key_tracker.borrow_mut(); + let mut key_tracker = child_key_tracker.entry(child.to_vec()) + .or_insert_with(|| HashMap::new()); + let mut read_write_tracker = self.read_write_tracker.borrow_mut(); + add_write_key_in_key_tracker(&mut key_tracker, &mut read_write_tracker, key); } } @@ -257,7 +293,7 @@ impl StateBackend> for BenchmarkingState { child_info: &ChildInfo, key: &[u8], ) -> Result>, Self::Error> { - self.add_read_key(key); + self.add_read_child_key(child_info.storage_key(), key); self.state.borrow().as_ref().ok_or_else(state_err)?.child_storage(child_info, key) } @@ -271,7 +307,7 @@ impl StateBackend> for BenchmarkingState { child_info: &ChildInfo, key: &[u8], ) -> Result { - self.add_read_key(key); + self.add_read_child_key(child_info.storage_key(), key); self.state.borrow().as_ref().ok_or_else(state_err)?.exists_child_storage(child_info, key) } @@ -285,7 +321,7 @@ impl StateBackend> for BenchmarkingState { child_info: &ChildInfo, key: &[u8], ) -> Result>, Self::Error> { - self.add_read_key(key); + self.add_read_child_key(child_info.storage_key(), key); self.state.borrow().as_ref().ok_or_else(state_err)?.next_child_storage_key(child_info, key) } @@ -362,9 +398,9 @@ impl StateBackend> for BenchmarkingState { fn commit(&self, storage_root: as Hasher>::Out, mut transaction: Self::Transaction, - storage_changes: StorageCollection, - ) -> Result<(), Self::Error> - { + main_storage_changes: StorageCollection, + child_storage_changes: ChildStorageCollection, + ) -> Result<(), Self::Error> { if let Some(db) = self.db.take() { let mut db_transaction = DBTransaction::new(); let changes = transaction.drain(); @@ -385,9 +421,14 @@ impl StateBackend> for BenchmarkingState { self.db.set(Some(db)); // Track DB Writes - storage_changes.iter().for_each(|(key, _)| { + main_storage_changes.iter().for_each(|(key, _)| { self.add_write_key(key); }); + child_storage_changes.iter().for_each(|(child_storage_key, storage_changes)| { + storage_changes.iter().for_each(|(key, _)| { + self.add_write_child_key(child_storage_key, key); + }) + }); } else { return Err("Trying to commit to a closed db".into()) } diff --git a/primitives/state-machine/src/backend.rs b/primitives/state-machine/src/backend.rs index 9ec03c4d1e249..e10c3d00de8a9 100644 --- a/primitives/state-machine/src/backend.rs +++ b/primitives/state-machine/src/backend.rs @@ -23,7 +23,7 @@ use sp_core::{traits::RuntimeCode, storage::{ChildInfo, well_known_keys}}; use crate::{ trie_backend::TrieBackend, trie_backend_essence::TrieBackendStorage, - UsageInfo, StorageKey, StorageValue, StorageCollection, + UsageInfo, StorageKey, StorageValue, StorageCollection, ChildStorageCollection, }; /// A state backend is used to read state data and can have changes committed @@ -212,7 +212,13 @@ pub trait Backend: std::fmt::Debug { } /// Commit given transaction to storage. - fn commit(&self, _: H::Out, _: Self::Transaction, _: StorageCollection) -> Result<(), Self::Error> { + fn commit( + &self, + _: H::Out, + _: Self::Transaction, + _: StorageCollection, + _: ChildStorageCollection, + ) -> Result<(), Self::Error> { unimplemented!() } diff --git a/primitives/state-machine/src/ext.rs b/primitives/state-machine/src/ext.rs index d7d4bc145eb06..a605add053dfe 100644 --- a/primitives/state-machine/src/ext.rs +++ b/primitives/state-machine/src/ext.rs @@ -594,6 +594,7 @@ where changes.transaction_storage_root, changes.transaction, changes.main_storage_changes, + changes.child_storage_changes, ).expect(EXT_NOT_ALLOWED_TO_FAIL); self.mark_dirty(); self.overlay From cf3941a65bfdc4b373aafb32af2399b1489fa0fc Mon Sep 17 00:00:00 2001 From: thiolliere Date: Mon, 17 Aug 2020 18:40:31 +0200 Subject: [PATCH 2/6] add test --- client/db/src/bench.rs | 40 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/client/db/src/bench.rs b/client/db/src/bench.rs index 580286f6f561a..61b64a987a746 100644 --- a/client/db/src/bench.rs +++ b/client/db/src/bench.rs @@ -485,3 +485,43 @@ impl std::fmt::Debug for BenchmarkingState { write!(f, "Bench DB") } } + +#[cfg(test)] +mod test { + use crate::bench::BenchmarkingState; + use sp_state_machine::backend::Backend as _; + + #[test] + fn read_to_main_and_child_tries() { + let bench_state = BenchmarkingState::::new(Default::default(), None) + .unwrap(); + + let child1 = sp_core::storage::ChildInfo::new_default(b"child1"); + let child2 = sp_core::storage::ChildInfo::new_default(b"child2"); + + bench_state.storage(b"foo").unwrap(); + bench_state.child_storage(&child1, b"foo").unwrap(); + bench_state.child_storage(&child2, b"foo").unwrap(); + + bench_state.storage(b"bar").unwrap(); + bench_state.child_storage(&child1, b"bar").unwrap(); + bench_state.child_storage(&child2, b"bar").unwrap(); + + bench_state.commit( + Default::default(), + Default::default(), + vec![ + ("foo".as_bytes().to_vec(), None) + ], + vec![ + ("child1".as_bytes().to_vec(), vec![("foo".as_bytes().to_vec(), None)]) + ] + ).unwrap(); + + let rw_tracker = bench_state.read_write_tracker.borrow(); + assert_eq!(rw_tracker.reads, 6); + assert_eq!(rw_tracker.repeat_reads, 0); + assert_eq!(rw_tracker.writes, 2); + assert_eq!(rw_tracker.repeat_writes, 0); + } +} From 89ca25f428d3b21bdb97a6ffd796d9682c0ddac1 Mon Sep 17 00:00:00 2001 From: thiolliere Date: Tue, 18 Aug 2020 09:59:06 +0200 Subject: [PATCH 3/6] refactor a bit + improve log --- client/db/src/bench.rs | 185 +++++++++++++++++++++-------------------- 1 file changed, 96 insertions(+), 89 deletions(-) diff --git a/client/db/src/bench.rs b/client/db/src/bench.rs index 61b64a987a746..2104116e7e1a6 100644 --- a/client/db/src/bench.rs +++ b/client/db/src/bench.rs @@ -104,62 +104,6 @@ pub struct BenchmarkingState { whitelist: RefCell>>, } -fn add_read_key_in_key_tracker( - key_tracker: &mut HashMap, KeyTracker>, - read_write_tracker: &mut ReadWriteTracker, - key: &[u8] -) { - let maybe_tracker = key_tracker.get(key); - - let has_been_read = KeyTracker { - has_been_read: true, - has_been_written: false, - }; - - match maybe_tracker { - None => { - key_tracker.insert(key.to_vec(), has_been_read); - read_write_tracker.add_read(); - }, - Some(tracker) => { - if !tracker.has_been_read { - key_tracker.insert(key.to_vec(), has_been_read); - read_write_tracker.add_read(); - } else { - read_write_tracker.add_repeat_read(); - } - } - } -} - -fn add_write_key_in_key_tracker( - key_tracker: &mut HashMap, KeyTracker>, - read_write_tracker: &mut ReadWriteTracker, - key: &[u8] -) { - let maybe_tracker = key_tracker.get(key); - - let has_been_written = KeyTracker { - has_been_read: true, - has_been_written: true, - }; - - match maybe_tracker { - None => { - key_tracker.insert(key.to_vec(), has_been_written); - read_write_tracker.add_write(); - }, - Some(tracker) => { - if !tracker.has_been_written { - key_tracker.insert(key.to_vec(), has_been_written); - read_write_tracker.add_write(); - } else { - read_write_tracker.add_repeat_write(); - } - } - } -} - impl BenchmarkingState { /// Create a new instance that creates a database in a temporary dir. pub fn new(genesis: Storage, _cache_size_mb: Option) -> Result { @@ -236,36 +180,99 @@ impl BenchmarkingState { *self.read_write_tracker.borrow_mut() = Default::default(); } - fn add_read_key(&self, key: &[u8]) { - log::trace!(target: "benchmark", "Read: {}", HexDisplay::from(&key)); - let mut key_tracker = self.key_tracker.borrow_mut(); + // Childtrie is identified by its storage key (i.e. `ChildInfo::storage_key`) + fn add_read_key(&self, childtrie: Option<&[u8]>, key: &[u8]) { let mut read_write_tracker = self.read_write_tracker.borrow_mut(); - add_read_key_in_key_tracker(&mut key_tracker, &mut read_write_tracker, key); - } + let mut child_key_tracker = self.child_key_tracker.borrow_mut(); + let mut top_key_tracker = self.key_tracker.borrow_mut(); - fn add_write_key(&self, key: &[u8]) { - log::trace!(target: "benchmark", "Write: {}", HexDisplay::from(&key)); - let mut key_tracker = self.key_tracker.borrow_mut(); - let mut read_write_tracker = self.read_write_tracker.borrow_mut(); - add_write_key_in_key_tracker(&mut key_tracker, &mut read_write_tracker, key); - } + let key_tracker = if let Some(childtrie) = childtrie { + child_key_tracker.entry(childtrie.to_vec()).or_insert_with(|| HashMap::new()) + } else { + &mut top_key_tracker + }; - fn add_read_child_key(&self, child: &[u8], key: &[u8]) { - log::trace!(target: "benchmark", "Read: {}", HexDisplay::from(&key)); - let mut child_key_tracker = self.child_key_tracker.borrow_mut(); - let mut key_tracker = child_key_tracker.entry(child.to_vec()) - .or_insert_with(|| HashMap::new()); - let mut read_write_tracker = self.read_write_tracker.borrow_mut(); - add_read_key_in_key_tracker(&mut key_tracker, &mut read_write_tracker, key); + let has_been_read = KeyTracker { + has_been_read: true, + has_been_written: false, + }; + + let read = match key_tracker.get(key) { + None => { + key_tracker.insert(key.to_vec(), has_been_read); + read_write_tracker.add_read(); + true + }, + Some(tracker) => { + if !tracker.has_been_read { + key_tracker.insert(key.to_vec(), has_been_read); + read_write_tracker.add_read(); + true + } else { + read_write_tracker.add_repeat_read(); + false + } + } + }; + + if read { + if let Some(childtrie) = childtrie { + log::trace!( + target: "benchmark", + "Childtrie Read: {} {}", HexDisplay::from(&childtrie), HexDisplay::from(&key) + ); + } else { + log::trace!(target: "benchmark", "Read: {}", HexDisplay::from(&key)); + } + } } - fn add_write_child_key(&self, child: &[u8], key: &[u8]) { - log::trace!(target: "benchmark", "Write: {}", HexDisplay::from(&key)); - let mut child_key_tracker = self.child_key_tracker.borrow_mut(); - let mut key_tracker = child_key_tracker.entry(child.to_vec()) - .or_insert_with(|| HashMap::new()); + // Childtrie is identified by its storage key (i.e. `ChildInfo::storage_key`) + fn add_write_key(&self, childtrie: Option<&[u8]>, key: &[u8]) { let mut read_write_tracker = self.read_write_tracker.borrow_mut(); - add_write_key_in_key_tracker(&mut key_tracker, &mut read_write_tracker, key); + let mut child_key_tracker = self.child_key_tracker.borrow_mut(); + let mut top_key_tracker = self.key_tracker.borrow_mut(); + + let key_tracker = if let Some(childtrie) = childtrie { + child_key_tracker.entry(childtrie.to_vec()).or_insert_with(|| HashMap::new()) + } else { + &mut top_key_tracker + }; + + // If we have written to the key, we also consider that we have read from it. + let has_been_written = KeyTracker { + has_been_read: true, + has_been_written: true, + }; + + let write = match key_tracker.get(key) { + None => { + key_tracker.insert(key.to_vec(), has_been_written); + read_write_tracker.add_write(); + true + }, + Some(tracker) => { + if !tracker.has_been_written { + key_tracker.insert(key.to_vec(), has_been_written); + read_write_tracker.add_write(); + true + } else { + read_write_tracker.add_repeat_write(); + false + } + } + }; + + if write { + if let Some(childtrie) = childtrie { + log::trace!( + target: "benchmark", + "Childtrie Write: {} {}", HexDisplay::from(&childtrie), HexDisplay::from(&key) + ); + } else { + log::trace!(target: "benchmark", "Write: {}", HexDisplay::from(&key)); + } + } } } @@ -279,12 +286,12 @@ impl StateBackend> for BenchmarkingState { type TrieBackendStorage = as StateBackend>>::TrieBackendStorage; fn storage(&self, key: &[u8]) -> Result>, Self::Error> { - self.add_read_key(key); + self.add_read_key(None, key); self.state.borrow().as_ref().ok_or_else(state_err)?.storage(key) } fn storage_hash(&self, key: &[u8]) -> Result, Self::Error> { - self.add_read_key(key); + self.add_read_key(None, key); self.state.borrow().as_ref().ok_or_else(state_err)?.storage_hash(key) } @@ -293,12 +300,12 @@ impl StateBackend> for BenchmarkingState { child_info: &ChildInfo, key: &[u8], ) -> Result>, Self::Error> { - self.add_read_child_key(child_info.storage_key(), key); + self.add_read_key(Some(child_info.storage_key()), key); self.state.borrow().as_ref().ok_or_else(state_err)?.child_storage(child_info, key) } fn exists_storage(&self, key: &[u8]) -> Result { - self.add_read_key(key); + self.add_read_key(None, key); self.state.borrow().as_ref().ok_or_else(state_err)?.exists_storage(key) } @@ -307,12 +314,12 @@ impl StateBackend> for BenchmarkingState { child_info: &ChildInfo, key: &[u8], ) -> Result { - self.add_read_child_key(child_info.storage_key(), key); + self.add_read_key(Some(child_info.storage_key()), key); self.state.borrow().as_ref().ok_or_else(state_err)?.exists_child_storage(child_info, key) } fn next_storage_key(&self, key: &[u8]) -> Result>, Self::Error> { - self.add_read_key(key); + self.add_read_key(None, key); self.state.borrow().as_ref().ok_or_else(state_err)?.next_storage_key(key) } @@ -321,7 +328,7 @@ impl StateBackend> for BenchmarkingState { child_info: &ChildInfo, key: &[u8], ) -> Result>, Self::Error> { - self.add_read_child_key(child_info.storage_key(), key); + self.add_read_key(Some(child_info.storage_key()), key); self.state.borrow().as_ref().ok_or_else(state_err)?.next_child_storage_key(child_info, key) } @@ -422,11 +429,11 @@ impl StateBackend> for BenchmarkingState { // Track DB Writes main_storage_changes.iter().for_each(|(key, _)| { - self.add_write_key(key); + self.add_write_key(None, key); }); child_storage_changes.iter().for_each(|(child_storage_key, storage_changes)| { storage_changes.iter().for_each(|(key, _)| { - self.add_write_child_key(child_storage_key, key); + self.add_write_key(Some(child_storage_key), key); }) }); } else { From c16b232404f409fba04285fbcfa3d6a0a8b0fcb7 Mon Sep 17 00:00:00 2001 From: thiolliere Date: Tue, 18 Aug 2020 10:01:07 +0200 Subject: [PATCH 4/6] better naming --- client/db/src/bench.rs | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/client/db/src/bench.rs b/client/db/src/bench.rs index 2104116e7e1a6..d6c3566ce2d8e 100644 --- a/client/db/src/bench.rs +++ b/client/db/src/bench.rs @@ -95,8 +95,8 @@ pub struct BenchmarkingState { genesis: HashMap, (Vec, i32)>, record: Cell>>, shared_cache: SharedCache, // shared cache is always empty - /// Key tracker for keys in the top trie. - key_tracker: RefCell, KeyTracker>>, + /// Key tracker for keys in the main trie. + main_key_tracker: RefCell, KeyTracker>>, /// Key tracker for keys in a child trie. /// Child trie are identified by their storage key (i.e. `ChildInfo::storage_key()`) child_key_tracker: RefCell, HashMap, KeyTracker>>>, @@ -119,7 +119,7 @@ impl BenchmarkingState { genesis_root: Default::default(), record: Default::default(), shared_cache: new_shared_cache(0, (1, 10)), - key_tracker: Default::default(), + main_key_tracker: Default::default(), child_key_tracker: Default::default(), read_write_tracker: Default::default(), whitelist: Default::default(), @@ -160,7 +160,7 @@ impl BenchmarkingState { } fn add_whitelist_to_tracker(&self) { - let mut key_tracker = self.key_tracker.borrow_mut(); + let mut main_key_tracker = self.main_key_tracker.borrow_mut(); let whitelisted = KeyTracker { has_been_read: true, @@ -170,12 +170,12 @@ impl BenchmarkingState { let whitelist = self.whitelist.borrow(); whitelist.iter().for_each(|key| { - key_tracker.insert(key.to_vec(), whitelisted); + main_key_tracker.insert(key.to_vec(), whitelisted); }); } fn wipe_tracker(&self) { - *self.key_tracker.borrow_mut() = HashMap::new(); + *self.main_key_tracker.borrow_mut() = HashMap::new(); self.add_whitelist_to_tracker(); *self.read_write_tracker.borrow_mut() = Default::default(); } @@ -184,12 +184,12 @@ impl BenchmarkingState { fn add_read_key(&self, childtrie: Option<&[u8]>, key: &[u8]) { let mut read_write_tracker = self.read_write_tracker.borrow_mut(); let mut child_key_tracker = self.child_key_tracker.borrow_mut(); - let mut top_key_tracker = self.key_tracker.borrow_mut(); + let mut main_key_tracker = self.main_key_tracker.borrow_mut(); let key_tracker = if let Some(childtrie) = childtrie { child_key_tracker.entry(childtrie.to_vec()).or_insert_with(|| HashMap::new()) } else { - &mut top_key_tracker + &mut main_key_tracker }; let has_been_read = KeyTracker { @@ -231,12 +231,12 @@ impl BenchmarkingState { fn add_write_key(&self, childtrie: Option<&[u8]>, key: &[u8]) { let mut read_write_tracker = self.read_write_tracker.borrow_mut(); let mut child_key_tracker = self.child_key_tracker.borrow_mut(); - let mut top_key_tracker = self.key_tracker.borrow_mut(); + let mut main_key_tracker = self.main_key_tracker.borrow_mut(); let key_tracker = if let Some(childtrie) = childtrie { child_key_tracker.entry(childtrie.to_vec()).or_insert_with(|| HashMap::new()) } else { - &mut top_key_tracker + &mut main_key_tracker }; // If we have written to the key, we also consider that we have read from it. From d0aadaeb6a12fc6c39f01b3c1b5725d19f085865 Mon Sep 17 00:00:00 2001 From: thiolliere Date: Thu, 20 Aug 2020 10:34:39 +0200 Subject: [PATCH 5/6] trigger CI --- client/db/src/bench.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/client/db/src/bench.rs b/client/db/src/bench.rs index 1c9be87faa0f3..ec6323545aa08 100644 --- a/client/db/src/bench.rs +++ b/client/db/src/bench.rs @@ -509,6 +509,7 @@ mod test { #[test] fn read_to_main_and_child_tries() { + let bench_state = BenchmarkingState::::new(Default::default(), None) .unwrap(); From 7e3c9eca5da0d9d2fd76f782329acae76410c1e3 Mon Sep 17 00:00:00 2001 From: thiolliere Date: Thu, 20 Aug 2020 10:34:46 +0200 Subject: [PATCH 6/6] Revert "trigger CI" This reverts commit d0aadaeb6a12fc6c39f01b3c1b5725d19f085865. --- client/db/src/bench.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/client/db/src/bench.rs b/client/db/src/bench.rs index ec6323545aa08..1c9be87faa0f3 100644 --- a/client/db/src/bench.rs +++ b/client/db/src/bench.rs @@ -509,7 +509,6 @@ mod test { #[test] fn read_to_main_and_child_tries() { - let bench_state = BenchmarkingState::::new(Default::default(), None) .unwrap();