chore: reduce realloc

Author: nkysg

crates/rbuilder/src/backtest/backtest_build_block.rs

@@ -319,7 +319,7 @@ fn print_onchain_block_data(
     orders: &[Order],
     block_data: &BlockData,
 ) {
-    let mut executed_orders = Vec::new();
+    let mut executed_orders = Vec::with_capacity(tx_sim_results.len());
 
     let txs_to_idx: HashMap<_, _> = tx_sim_results
         .iter()

crates/rbuilder/src/backtest/fetch/flashbots_db.rs

@@ -1,13 +1,11 @@
-use crate::backtest::BuiltBlockData;
-use crate::primitives::OrderId;
 use crate::{
     backtest::{
         fetch::data_source::{BlockRef, DataSource, DatasourceData},
-        OrdersWithTimestamp,
+        BuiltBlockData, OrdersWithTimestamp,
     },
     primitives::{
         serialize::{RawBundle, RawOrder, RawShareBundle, TxEncoding},
-        Order, SimValue,
+        Order, OrderId, SimValue,
     },
 };
 use alloy_primitives::I256;
@@ -19,8 +17,7 @@ use bigdecimal::{
 use eyre::WrapErr;
 use reth_primitives::{Bytes, B256, U256, U64};
 use sqlx::postgres::PgPool;
-use std::collections::HashSet;
-use std::{ops::Mul, str::FromStr};
+use std::{collections::HashSet, ops::Mul, str::FromStr};
 use time::{OffsetDateTime, PrimitiveDateTime};
 use tracing::trace;
 use uuid::Uuid;
@@ -333,7 +330,8 @@ impl RelayDB {
         .fetch_all(&self.pool)
         .await?;
 
-        let mut included_orders = Vec::new();
+        let mut included_orders =
+            Vec::with_capacity(included_bundles.len() + included_sbundles.len());
         for (bundle_uuid,) in included_bundles {
             let order_id = OrderId::Bundle(bundle_uuid);
             included_orders.push(order_id);

crates/rbuilder/src/backtest/fetch/mempool.rs

@@ -1,9 +1,8 @@
 //! Implementation of [`DataSource`] to bring mempool txs from flashbots' mempool dumpster.
 //! It downloads all the needed parquet files and keeps them cached for future use.
-use crate::backtest::fetch::data_source::DatasourceData;
 use crate::{
     backtest::{
-        fetch::data_source::{BlockRef, DataSource},
+        fetch::data_source::{BlockRef, DataSource, DatasourceData},
         OrdersWithTimestamp,
     },
     primitives::{

crates/rbuilder/src/backtest/mod.rs

@@ -12,14 +12,13 @@ pub use backtest_build_block::run_backtest_build_block;
 pub use backtest_build_range::run_backtest_build_range;
 use std::collections::HashSet;
 
-use crate::primitives::{OrderId, OrderReplacementKey};
-use crate::utils::offset_datetime_to_timestamp_ms;
 use crate::{
     mev_boost::BuilderBlockReceived,
     primitives::{
         serialize::{RawOrder, RawOrderConvertError, TxEncoding},
-        AccountNonce, Order, SimValue,
+        AccountNonce, Order, OrderId, OrderReplacementKey, SimValue,
     },
+    utils::offset_datetime_to_timestamp_ms,
 };
 use alloy_primitives::{Address, TxHash, I256};
 use alloy_rpc_types::{BlockTransactions, Transaction};

crates/rbuilder/src/backtest/redistribute/cli/csv_output.rs

@@ -1,8 +1,5 @@
 use alloy_primitives::{Address, B256, U256};
-use std::fs::File;
-use std::io;
-use std::io::Write;
-use std::path::Path;
+use std::{fs::File, io, io::Write, path::Path};
 
 #[derive(Debug)]
 pub struct CSVOutputRow {

crates/rbuilder/src/backtest/redistribute/mod.rs

@@ -293,7 +293,7 @@ where
     })
     .collect::<Vec<_>>();
 
-    let mut simplified_orders = Vec::new();
+    let mut simplified_orders = Vec::with_capacity(included_orders_available.len());
 
     for available_order in included_orders_available {
         simplified_orders.push(SimplifiedOrder::new_from_order(&available_order.order));
@@ -880,7 +880,11 @@ fn calc_inclusion_change(
     exclusion_result: &ExclusionResult,
     included_before: &[(OrderId, U256)],
 ) -> Vec<OrderInclusionChange> {
-    let mut result = Vec::new();
+    let mut result = Vec::with_capacity(
+        exclusion_result.new_orders_included.len()
+            + exclusion_result.new_orders_failed.len()
+            + exclusion_result.orders_profit_changed.len(),
+    );
     for (id, profit_after) in &exclusion_result.new_orders_included {
         result.push((
             *id,

crates/rbuilder/src/backtest/redistribute/redistribution_algo.rs

@@ -141,10 +141,11 @@ pub fn calculate_redistribution(data: RedistributionCalculator) -> Redistributio
     }
 
     let mut total_value_redistributed = U256::ZERO;
-    let mut redistribution_entity_result = Vec::new();
+    let mut redistribution_entity_result = Vec::with_capacity(n);
     for i in 0..n {
-        let mut order_id_vector = Vec::new();
-        let mut order_contrib_vector = Vec::new();
+        let mut order_id_vector = Vec::with_capacity(data.identity_data[i].included_orders.len());
+        let mut order_contrib_vector =
+            Vec::with_capacity(data.identity_data[i].included_orders.len());
         for landed_order in &data.identity_data[i].included_orders {
             order_id_vector.push(landed_order.id);
             order_contrib_vector.push(landed_order.realized_value);
@@ -230,7 +231,7 @@ fn split_value(value: U256, split_vector: &[U256]) -> Vec<U256> {
     if total_split.is_zero() {
         return split_vector.iter().map(|_| U256::ZERO).collect();
     }
-    let mut result = Vec::new();
+    let mut result = Vec::with_capacity(split_vector.len());
     for split in split_vector {
         result.push((value * split) / total_split);
     }

crates/rbuilder/src/backtest/restore_landed_orders/find_landed_orders.rs

@@ -1,5 +1,7 @@
-use crate::primitives::{Order, OrderId, ShareBundleBody, ShareBundleInner, TxRevertBehavior};
-use crate::utils::get_percent;
+use crate::{
+    primitives::{Order, OrderId, ShareBundleBody, ShareBundleInner, TxRevertBehavior},
+    utils::get_percent,
+};
 use ahash::HashMap;
 use alloy_primitives::{B256, I256, U256};
 
@@ -408,8 +410,10 @@ fn find_landed_order_data(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::primitives::{Bundle, MempoolTx, Refund, ShareBundle, ShareBundleTx};
-    use crate::utils::test_utils::*;
+    use crate::{
+        primitives::{Bundle, MempoolTx, Refund, ShareBundle, ShareBundleTx},
+        utils::test_utils::*,
+    };
 
     fn assert_result(
         executed_txs: Vec<ExecutedBlockTx>,

crates/rbuilder/src/backtest/store.rs

@@ -1,17 +1,17 @@
 // store orders in the sqlite database
 
-use crate::backtest::BuiltBlockData;
-use crate::primitives::OrderId;
-use crate::utils::timestamp_ms_to_offset_datetime;
 use crate::{
-    backtest::{BlockData, OrdersWithTimestamp, RawOrdersWithTimestamp},
+    backtest::{BlockData, BuiltBlockData, OrdersWithTimestamp, RawOrdersWithTimestamp},
     mev_boost::BuilderBlockReceived,
-    primitives::serialize::{RawOrder, TxEncoding},
+    primitives::{
+        serialize::{RawOrder, TxEncoding},
+        OrderId,
+    },
+    utils::timestamp_ms_to_offset_datetime,
 };
 use ahash::{HashMap, HashSet};
-use alloy_primitives::utils::{ParseUnits, Unit};
 use alloy_primitives::{
-    utils::{format_ether, parse_ether},
+    utils::{format_ether, parse_ether, ParseUnits, Unit},
     Address, B256, I256, U256,
 };
 use lz4_flex::{block::DecompressError, compress_prepend_size, decompress_size_prepended};
@@ -20,10 +20,10 @@ use sqlx::{
     sqlite::{SqliteConnectOptions, SqliteRow},
     ConnectOptions, Connection, Executor, Row, SqliteConnection,
 };
-use std::str::FromStr;
 use std::{
     ffi::OsString,
     path::{Path, PathBuf},
+    str::FromStr,
 };
 
 /// Version of the data/format on the DB.

crates/rbuilder/src/bin/backtest-distribute.rs

@@ -1,5 +1,4 @@
-use rbuilder::backtest::redistribute::run_backtest_redistribute;
-use rbuilder::live_builder::config::Config;
+use rbuilder::{backtest::redistribute::run_backtest_redistribute, live_builder::config::Config};
 
 #[tokio::main]
 async fn main() -> eyre::Result<()> {

crates/rbuilder/src/building/block_orders/mod.rs

@@ -197,6 +197,7 @@ pub fn block_orders_from_sim_orders(
 ) -> ProviderResult<BlockOrders> {
     let mut onchain_nonces = vec![];
     for order in sim_orders {
+        onchain_nonces.reserve_exact(order.order.nonces().len());
         for nonce in order.order.nonces() {
             let value = state_provider
                 .account_nonce(nonce.address)?

crates/rbuilder/src/building/block_orders/test_context.rs

@@ -111,7 +111,7 @@ impl<TestedSinkType: SimulatedOrderSink> TestContext<TestedSinkType> {
     /// tx is the same in all backruns
     pub fn create_multiple_sbundle_tx_br(&mut self, sbundle_count: usize) -> Vec<ShareBundle> {
         let tx = self.create_share_bundle_tx_bundle(TxRevertBehavior::AllowedExcluded);
-        let mut res = Vec::new();
+        let mut res = Vec::with_capacity(sbundle_count);
         for _ in 0..sbundle_count {
             let body = vec![
                 tx.clone(),

crates/rbuilder/src/building/builders/ordering_builder.rs

@@ -5,7 +5,6 @@
 //! The described algorithm is ran continuously adding new SimulatedOrders (they arrive on real time!) on each iteration until we run out of time (slot ends).
 //! Sorting criteria are described on [`Sorting`].
 //! For some more details see [`OrderingBuilderConfig`]
-use crate::roothash::RootHashConfig;
 use crate::{
     building::{
         block_orders_from_sim_orders,
@@ -15,6 +14,7 @@ use crate::{
         BlockBuildingContext, BlockOrders, ExecutionError, Sorting,
     },
     primitives::{AccountNonce, OrderId},
+    roothash::RootHashConfig,
 };
 use ahash::{HashMap, HashSet};
 use alloy_primitives::Address;

crates/rbuilder/src/building/builders/parallel_builder/block_building_result_assembler.rs

@@ -8,8 +8,7 @@ use reth::tasks::pool::BlockingTaskPool;
 use reth_db::Database;
 use reth_payload_builder::database::CachedReads;
 use reth_provider::{DatabaseProviderFactory, StateProviderFactory};
-use std::sync::Arc;
-use std::{marker::PhantomData, time::Instant};
+use std::{marker::PhantomData, sync::Arc, time::Instant};
 use time::OffsetDateTime;
 use tokio_util::sync::CancellationToken;
 use tracing::{trace, warn};

crates/rbuilder/src/building/builders/parallel_builder/conflict_resolvers.rs

@@ -10,12 +10,15 @@ use std::sync::Arc;
 use tokio_util::sync::CancellationToken;
 use tracing::trace;
 
-use super::simulation_cache::{CachedSimulationState, SharedSimulationCache};
-use super::{Algorithm, ConflictTask, ResolutionResult};
+use super::{
+    simulation_cache::{CachedSimulationState, SharedSimulationCache},
+    Algorithm, ConflictTask, ResolutionResult,
+};
 
-use crate::building::{BlockBuildingContext, BlockState, PartialBlock};
-use crate::building::{ExecutionError, ExecutionResult};
-use crate::primitives::{OrderId, SimulatedOrder};
+use crate::{
+    building::{BlockBuildingContext, BlockState, ExecutionError, ExecutionResult, PartialBlock},
+    primitives::{OrderId, SimulatedOrder},
+};
 
 /// Context for resolving conflicts in merging tasks.
 #[derive(Debug)]
@@ -352,7 +355,7 @@ fn generate_sequences_of_orders_to_try(task: &ConflictTask) -> Vec<Vec<usize>> {
 ///
 /// A vector of randomly generated sequences of order indices.
 fn generate_random_permutations(task: &ConflictTask, seed: u64, count: usize) -> Vec<Vec<usize>> {
-    let mut sequences_of_orders = vec![];
+    let mut sequences_of_orders = Vec::with_capacity(count);
 
     let order_group = &task.group;
     let mut indexes = (0..order_group.orders.len()).collect::<Vec<_>>();

crates/rbuilder/src/building/builders/parallel_builder/conflict_resolving_pool.rs

@@ -3,18 +3,17 @@ use crossbeam_queue::SegQueue;
 use eyre::Result;
 use rayon::{ThreadPool, ThreadPoolBuilder};
 use reth_provider::StateProviderFactory;
-use std::sync::mpsc as std_mpsc;
-use std::sync::Arc;
-use std::time::Instant;
+use std::{
+    sync::{mpsc as std_mpsc, Arc},
+    time::Instant,
+};
 use tokio_util::sync::CancellationToken;
 use tracing::{trace, warn};
 
-use super::conflict_task_generator::get_tasks_for_group;
-use super::ConflictResolutionResultPerGroup;
-use super::TaskPriority;
 use super::{
-    conflict_resolvers::ResolverContext, simulation_cache::SharedSimulationCache, ConflictGroup,
-    ConflictTask, GroupId, ResolutionResult,
+    conflict_resolvers::ResolverContext, conflict_task_generator::get_tasks_for_group,
+    simulation_cache::SharedSimulationCache, ConflictGroup, ConflictResolutionResultPerGroup,
+    ConflictTask, GroupId, ResolutionResult, TaskPriority,
 };
 use crate::building::BlockBuildingContext;
 

crates/rbuilder/src/building/builders/parallel_builder/conflict_task_generator.rs

@@ -1,18 +1,15 @@
 use crate::primitives::SimulatedOrder;
-use ahash::HashMap;
-use ahash::HashSet;
+use ahash::{HashMap, HashSet};
 use alloy_primitives::{utils::format_ether, U256};
 use crossbeam_queue::SegQueue;
 use itertools::Itertools;
 use std::time::Instant;
 use tracing::{trace, warn};
 
-use super::task::ConflictTask;
-use super::ConflictGroup;
-use super::ConflictResolutionResultPerGroup;
-use super::GroupId;
-use super::ResolutionResult;
-use super::{Algorithm, TaskPriority, TaskQueue};
+use super::{
+    task::ConflictTask, Algorithm, ConflictGroup, ConflictResolutionResultPerGroup, GroupId,
+    ResolutionResult, TaskPriority, TaskQueue,
+};
 use std::sync::mpsc as std_mpsc;
 
 const THRESHOLD_FOR_SIGNIFICANT_CHANGE: u64 = 20;

crates/rbuilder/src/building/builders/parallel_builder/mod.rs

@@ -18,9 +18,11 @@ use itertools::Itertools;
 use results_aggregator::BestResults;
 use serde::Deserialize;
 use simulation_cache::SharedSimulationCache;
-use std::sync::mpsc as std_mpsc;
-use std::thread;
-use std::{sync::Arc, time::Instant};
+use std::{
+    sync::{mpsc as std_mpsc, Arc},
+    thread,
+    time::Instant,
+};
 use task::*;
 use time::OffsetDateTime;
 use tokio_util::sync::CancellationToken;

crates/rbuilder/src/building/builders/parallel_builder/results_aggregator.rs

@@ -1,13 +1,13 @@
 use super::{ConflictGroup, GroupId, ResolutionResult};
-use alloy_primitives::utils::format_ether;
-use alloy_primitives::U256;
+use alloy_primitives::{utils::format_ether, U256};
 use dashmap::DashMap;
-use std::sync::mpsc as std_mpsc;
-use std::sync::{
-    atomic::{AtomicU64, Ordering},
-    Arc,
+use std::{
+    sync::{
+        atomic::{AtomicU64, Ordering},
+        mpsc as std_mpsc, Arc,
+    },
+    time::{Duration, Instant},
 };
-use std::time::{Duration, Instant};
 use tokio_util::sync::CancellationToken;
 use tracing::trace;
 

crates/rbuilder/src/building/builders/parallel_builder/simulation_cache.rs

@@ -4,8 +4,10 @@ use alloy_primitives::U256;
 use parking_lot::RwLock as PLRwLock;
 use reth_payload_builder::database::CachedReads;
 use revm::db::BundleState;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::Arc;
+use std::sync::{
+    atomic::{AtomicUsize, Ordering},
+    Arc,
+};
 
 /// An instance of a simulation result that has been cached.
 #[derive(Debug, Clone)]

crates/rbuilder/src/building/built_block_trace.rs

@@ -2,8 +2,7 @@ use super::{BundleErr, ExecutionError, ExecutionResult, OrderErr};
 use crate::primitives::{Order, OrderId, OrderReplacementKey};
 use ahash::{HashMap, HashSet};
 use alloy_primitives::{Address, TxHash, U256};
-use std::collections::hash_map;
-use std::time::Duration;
+use std::{collections::hash_map, time::Duration};
 use time::OffsetDateTime;
 
 /// Structs for recording data about a built block, such as what bundles were included, and where txs came from.

crates/rbuilder/src/live_builder/block_output/bidding/wallet_balance_watcher.rs

@@ -154,7 +154,7 @@ where
             }
             return Ok(Vec::new());
         }
-        let mut res = Vec::new();
+        let mut res = Vec::with_capacity(new_block.saturating_sub(self.block_number) as usize);
         for block_number in self.block_number + 1..=new_block {
             let block_info = self.get_block_info(block_number)?;
             res.push(block_info.as_landed_block_info(&self.builder_addr));

crates/rbuilder/src/live_builder/block_output/block_sealing_bidder_factory.rs

@@ -4,8 +4,7 @@ use crate::{
 };
 use alloy_primitives::U256;
 use reth_provider::{HeaderProvider, StateProviderFactory};
-use std::fmt::Debug;
-use std::sync::Arc;
+use std::{fmt::Debug, sync::Arc};
 use tracing::error;
 
 use super::{