test: add new logs

Author: pythonberg1997

crates/trie/parallel/src/parallel_root.rs

@@ -132,13 +132,16 @@ where
         let mut hash_builder = HashBuilder::default().with_updates(retain_updates);
         let mut account_rlp = Vec::with_capacity(128);
         let start = std::time::Instant::now();
-        let mut hash_elapsed = 0;
+        let mut hash_elapsed_branch = 0;
+        let mut hash_elapsed_leaf = 0;
+        let mut hash_elapsed_miss = 0;
         while let Some(node) = account_node_iter.try_next().map_err(ProviderError::Database)? {
-            let start = std::time::Instant::now();
             match node {
                 TrieElement::Branch(node) => {
+                    let start = std::time::Instant::now();
                     tracker.inc_branch();
                     hash_builder.add_branch(node.key, node.value, node.children_are_in_trie);
+                    hash_elapsed_branch += start.elapsed().as_micros();
                 }
                 TrieElement::Leaf(hashed_address, account) => {
                     let (storage_root, _, updates) = match storage_roots.remove(&hashed_address) {
@@ -149,34 +152,43 @@ where
                         // Since we do not store all intermediate nodes in the database, there might
                         // be a possibility of re-adding a non-modified leaf to the hash builder.
                         None => {
+                            let start = std::time::Instant::now();
                             tracker.inc_missed_leaves();
-                            StorageRoot::new_hashed(
+                            let result = StorageRoot::new_hashed(
                                 trie_cursor_factory.clone(),
                                 hashed_cursor_factory.clone(),
                                 hashed_address,
                                 #[cfg(feature = "metrics")]
                                 self.metrics.storage_trie.clone(),
                             )
-                            .calculate(retain_updates)?
+                            .calculate(retain_updates)?;
+                            hash_elapsed_miss += start.elapsed().as_micros();
+
+                            result
                         }
                     };
 
                     if retain_updates {
                         trie_updates.insert_storage_updates(hashed_address, updates);
                     }
 
+                    let start = std::time::Instant::now();
                     account_rlp.clear();
                     let account = TrieAccount::from((account, storage_root));
                     account.encode(&mut account_rlp as &mut dyn BufMut);
                     hash_builder.add_leaf(Nibbles::unpack(hashed_address), &account_rlp);
+                    hash_elapsed_leaf += start.elapsed().as_micros();
                 }
             }
-            hash_elapsed += start.elapsed().as_micros();
         }
         debug!(target: "trie::parallel_state_root", "test info: total elapsed in account node {:?}", start.elapsed());
-        debug!(target: "trie::parallel_state_root", "test info: hash elapsed in account node {:?}us", hash_elapsed);
+        debug!(target: "trie::parallel_state_root", "test info: hash elapsed in account node {:?}us", hash_elapsed_branch);
+        debug!(target: "trie::parallel_state_root", "test info: hash elapsed in account node {:?}us", hash_elapsed_leaf);
+        debug!(target: "trie::parallel_state_root", "test info: hash elapsed in account node {:?}us", hash_elapsed_miss);
 
+        let start = std::time::Instant::now();
         let root = hash_builder.root();
+        debug!(target: "trie::parallel_state_root", "test info: elapsed in hash builder root {:?}", start.elapsed());
 
         trie_updates.finalize(
             account_node_iter.walker,

crates/trie/prefetch/src/prefetch.rs

@@ -79,9 +79,9 @@ impl TriePrefetch {
                         let hashed_state = self.deduplicate_and_update_cached(state);
 
                         let self_clone = Arc::new(self.clone());
-                        let global_stats = Arc::clone(&self.global_stats);
+                        // let global_stats = Arc::clone(&self.global_stats);
                         join_set.spawn(async move {
-                            if let Err(e) = self_clone.prefetch_once::<DB>(consistent_view, hashed_state, global_stats).await {
+                            if let Err(e) = self_clone.prefetch_once::<DB>(consistent_view, hashed_state).await {
                                 debug!(target: "trie::trie_prefetch", ?e, "Error while prefetching trie storage");
                             };
                         });
@@ -90,7 +90,7 @@ impl TriePrefetch {
                 _ = &mut interrupt_rx => {
                     debug!(target: "trie::trie_prefetch", "Interrupted trie prefetch task. Unprocessed tx {:?}", prefetch_rx.len());
                     join_set.abort_all();
-                    debug!(target: "trie::trie_prefetch", "test info: prefetch trie node count: {:?}", self.global_stats.lock().await);
+                    // debug!(target: "trie::trie_prefetch", "test info: prefetch trie node count: {:?}", self.global_stats.lock().await);
                     return
                 }
             }
@@ -152,7 +152,7 @@ impl TriePrefetch {
         self: Arc<Self>,
         consistent_view: Arc<ConsistentDbView<DB, ProviderFactory<DB>>>,
         hashed_state: HashedPostState,
-        global_stats: Arc<Mutex<GlobalStats>>,
+        // global_stats: Arc<Mutex<GlobalStats>>,
     ) -> Result<(), TriePrefetchError>
     where
         DB: Database,
@@ -213,21 +213,21 @@ impl TriePrefetch {
             match node {
                 TrieElement::Branch(_) => {
                     tracker.inc_branch();
-                    let mut stats = global_stats.lock().await;
-                    stats.branch_count += 1;
+                    // let mut stats = global_stats.lock().await;
+                    // stats.branch_count += 1;
                 }
                 TrieElement::Leaf(hashed_address, _) => {
                     match storage_roots.remove(&hashed_address) {
                         Some(result) => {
-                            let mut stats = global_stats.lock().await;
-                            stats.leaf_count += 1;
+                            // let mut stats = global_stats.lock().await;
+                            // stats.leaf_count += 1;
                             result
                         }
                         // Since we do not store all intermediate nodes in the database, there might
                         // be a possibility of re-adding a non-modified leaf to the hash builder.
                         None => {
-                            let mut stats = global_stats.lock().await;
-                            stats.missing_count += 1;
+                            // let mut stats = global_stats.lock().await;
+                            // stats.missing_count += 1;
 
                             StorageRoot::new_hashed(
                                 trie_cursor_factory.clone(),