fmt

Author: yongkangc

crates/engine/tree/src/tree/payload_processor/multiproof.rs

@@ -1047,13 +1047,13 @@ impl MultiProofTask {
                     Vec::with_capacity(PREFETCH_MAX_BATCH_MESSAGES);
                 accumulated_targets.push(targets);
 
-                // Fast-path dispatch if the first message already fills the batch.
-                if accumulated_count < PREFETCH_MAX_BATCH_TARGETS
-                    && accumulated_targets.len() < PREFETCH_MAX_BATCH_MESSAGES
+                // Only attempt batching if below limits; otherwise skip straight to dispatch.
+                if accumulated_count < PREFETCH_MAX_BATCH_TARGETS &&
+                    accumulated_targets.len() < PREFETCH_MAX_BATCH_MESSAGES
                 {
                     loop {
-                        if accumulated_count >= PREFETCH_MAX_BATCH_TARGETS
-                            || accumulated_targets.len() >= PREFETCH_MAX_BATCH_MESSAGES
+                        if accumulated_count >= PREFETCH_MAX_BATCH_TARGETS ||
+                            accumulated_targets.len() >= PREFETCH_MAX_BATCH_MESSAGES
                         {
                             break;
                         }
@@ -1488,8 +1488,8 @@ fn get_proof_targets(
             .storage
             .keys()
             .filter(|slot| {
-                !fetched.is_some_and(|f| f.contains(*slot))
-                    || storage_added_removed_keys.is_some_and(|k| k.is_removed(slot))
+                !fetched.is_some_and(|f| f.contains(*slot)) ||
+                    storage_added_removed_keys.is_some_and(|k| k.is_removed(slot))
             })
             .peekable();
 
@@ -1522,20 +1522,20 @@ fn dispatch_with_chunking<T, I>(
 where
     I: IntoIterator<Item = T>,
 {
-    let should_chunk = chunking_len > max_targets_for_chunking
-        || available_account_workers > 1
-        || available_storage_workers > 1;
+    let should_chunk = chunking_len > max_targets_for_chunking ||
+        available_account_workers > 1 ||
+        available_storage_workers > 1;
 
-    if should_chunk
-        && let Some(chunk_size) = chunk_size
-        && chunking_len > chunk_size
+    if should_chunk &&
+        let Some(chunk_size) = chunk_size &&
+        chunking_len > chunk_size
     {
-        let mut dispatched = 0usize;
+        let mut num_chunks = 0usize;
         for chunk in chunker(items, chunk_size) {
             dispatch(chunk);
-            dispatched += 1;
+            num_chunks += 1;
         }
-        return dispatched;
+        return num_chunks;
     }
 
     dispatch(items);
@@ -1544,8 +1544,9 @@ where
 
 /// Checks whether two state updates can be merged in a batch.
 ///
-/// Transaction updates that share the same `StateChangeSource::Transaction` are safe to merge
-/// because they originate from one logical execution and can be coalesced to amortize proof work.
+/// Transaction updates with the same transaction ID (`StateChangeSource::Transaction(id)`)
+/// are safe to merge because they originate from the same logical execution and can be
+/// coalesced to amortize proof work.
 fn can_batch_state_update(
     batch_source: StateChangeSource,
     batch_update: &EvmState,
@@ -1557,8 +1558,8 @@ fn can_batch_state_update(
     }
 
     match (batch_source, next_source) {
-        (StateChangeSource::PreBlock(_), StateChangeSource::PreBlock(_))
-        | (StateChangeSource::PostBlock(_), StateChangeSource::PostBlock(_)) => {
+        (StateChangeSource::PreBlock(_), StateChangeSource::PreBlock(_)) |
+        (StateChangeSource::PostBlock(_), StateChangeSource::PostBlock(_)) => {
             batch_update == next_update
         }
         _ => true,
@@ -2250,8 +2251,8 @@ mod tests {
                 }
                 match task.rx.try_recv() {
                     Ok(MultiProofMessage::StateUpdate(next_source, next_update)) => {
-                        if let Some((batch_source, batch_update)) = accumulated_updates.first()
-                            && !can_batch_state_update(
+                        if let Some((batch_source, batch_update)) = accumulated_updates.first() &&
+                            !can_batch_state_update(
                                 *batch_source,
                                 batch_update,
                                 next_source,
@@ -2269,8 +2270,8 @@ mod tests {
                                 Some(MultiProofMessage::StateUpdate(next_source, next_update));
                             break;
                         }
-                        if accumulated_targets + next_estimate > STATE_UPDATE_MAX_BATCH_TARGETS
-                            && !accumulated_updates.is_empty()
+                        if accumulated_targets + next_estimate > STATE_UPDATE_MAX_BATCH_TARGETS &&
+                            !accumulated_updates.is_empty()
                         {
                             pending_msg =
                                 Some(MultiProofMessage::StateUpdate(next_source, next_update));
@@ -2372,8 +2373,8 @@ mod tests {
                 }
                 match task.rx.try_recv() {
                     Ok(MultiProofMessage::StateUpdate(next_source, next_update)) => {
-                        if let Some((batch_source, batch_update)) = accumulated_updates.first()
-                            && !can_batch_state_update(
+                        if let Some((batch_source, batch_update)) = accumulated_updates.first() &&
+                            !can_batch_state_update(
                                 *batch_source,
                                 batch_update,
                                 next_source,
@@ -2391,8 +2392,8 @@ mod tests {
                                 Some(MultiProofMessage::StateUpdate(next_source, next_update));
                             break;
                         }
-                        if accumulated_targets + next_estimate > STATE_UPDATE_MAX_BATCH_TARGETS
-                            && !accumulated_updates.is_empty()
+                        if accumulated_targets + next_estimate > STATE_UPDATE_MAX_BATCH_TARGETS &&
+                            !accumulated_updates.is_empty()
                         {
                             pending_msg =
                                 Some(MultiProofMessage::StateUpdate(next_source, next_update));