perf(l1): remove redundant ancestor deletes in healing trie writes

crates/networking/p2p/sync/healing/state.rs

@@ -10,7 +10,7 @@
 
 use std::{
     cmp::min,
-    collections::{BTreeMap, HashMap},
+    collections::HashMap,
     sync::atomic::Ordering,
     time::{Duration, Instant},
 };
@@ -283,24 +283,20 @@ async fn heal_state_trie(
             // PERF: reuse buffers?
             let to_write = std::mem::take(&mut nodes_to_write);
             let store = store.clone();
-            // NOTE: we keep only a single task in the background to avoid out of order deletes
+            // NOTE: we keep only a single task in the background to preserve write ordering
             if !db_joinset.is_empty()
                 && let Some(result) = db_joinset.join_next().await
             {
                 result??;
             }
             db_joinset.spawn_blocking(move || -> Result<(), SyncError> {
-                let mut encoded_to_write = BTreeMap::new();
-                for (path, node) in to_write {
-                    for i in 0..path.len() {
-                        encoded_to_write.insert(path.slice(0, i), vec![]);
-                    }
-                    encoded_to_write.insert(path, node.encode_to_vec());
-                }
+                let encoded_to_write: Vec<_> = to_write
+                    .into_iter()
+                    .map(|(path, node)| (path, node.encode_to_vec()))
+                    .collect();
                 let trie_db = store.open_direct_state_trie(*EMPTY_TRIE_HASH)?;
                 let db = trie_db.db();
-                // PERF: use put_batch_no_alloc (note that it needs to remove nodes too)
-                db.put_batch(encoded_to_write.into_iter().collect())?;
+                db.put_batch(encoded_to_write)?;
                 Ok(())
             });
         }

crates/networking/p2p/sync/healing/storage.rs

@@ -212,23 +212,19 @@ pub async fn heal_storage_trie(
         if nodes_to_write.values().map(Vec::len).sum::<usize>() > 100_000 || is_done || is_stale {
             let to_write: Vec<_> = nodes_to_write.drain().collect();
             let store = state.store.clone();
-            // NOTE: we keep only a single task in the background to avoid out of order deletes
+            // NOTE: we keep only a single task in the background to preserve write ordering
             if !db_joinset.is_empty() {
                 db_joinset.join_next().await;
             }
             db_joinset.spawn_blocking(move || {
                 let mut encoded_to_write = vec![];
                 for (hashed_account, nodes) in to_write {
-                    let mut account_nodes = vec![];
-                    for (path, node) in nodes {
-                        for i in 0..path.len() {
-                            account_nodes.push((path.slice(0, i), vec![]));
-                        }
-                        account_nodes.push((path, node.encode_to_vec()));
-                    }
+                    let account_nodes = nodes
+                        .into_iter()
+                        .map(|(path, node)| (path, node.encode_to_vec()))
+                        .collect();
                     encoded_to_write.push((hashed_account, account_nodes));
                 }
-                // PERF: use put_batch_no_alloc? (it needs to remove parent nodes too)
                 spawned_rt::tasks::block_on(store.write_storage_trie_nodes_batch(encoded_to_write))
                     .expect("db write failed");
             });