optional prioritization_fee_cache

banking-bench/src/main.rs

@@ -23,9 +23,7 @@ use {
     solana_measure::measure::Measure,
     solana_perf::packet::{to_packet_batches, PacketBatch},
     solana_poh::poh_recorder::{create_test_recorder, PohRecorder, WorkingBankEntry},
-    solana_runtime::{
-        bank::Bank, bank_forks::BankForks, prioritization_fee_cache::PrioritizationFeeCache,
-    },
+    solana_runtime::{bank::Bank, bank_forks::BankForks},
     solana_sdk::{
         compute_budget::ComputeBudgetInstruction,
         hash::Hash,
@@ -481,7 +479,7 @@ fn main() {
         None,
         Arc::new(connection_cache),
         bank_forks.clone(),
-        &Arc::new(PrioritizationFeeCache::new(0u64)),
+        None,
         false,
     );
 

core/benches/banking_stage.rs

@@ -39,9 +39,7 @@ use {
         test_tx::test_tx,
     },
     solana_poh::poh_recorder::{create_test_recorder, WorkingBankEntry},
-    solana_runtime::{
-        bank::Bank, bank_forks::BankForks, prioritization_fee_cache::PrioritizationFeeCache,
-    },
+    solana_runtime::{bank::Bank, bank_forks::BankForks},
     solana_sdk::{
         genesis_config::GenesisConfig,
         hash::Hash,
@@ -109,7 +107,7 @@ fn bench_consume_buffered(bencher: &mut Bencher) {
         ThreadType::Transactions,
     );
     let (s, _r) = unbounded();
-    let committer = Committer::new(None, s, Arc::new(PrioritizationFeeCache::new(0u64)));
+    let committer = Committer::new(None, s, None);
     let consumer = Consumer::new(committer, recorder, QosService::new(1), None);
     // This tests the performance of buffering packets.
     // If the packet buffers are copied, performance will be poor.
@@ -307,7 +305,7 @@ fn bench_banking(bencher: &mut Bencher, tx_type: TransactionType) {
         None,
         Arc::new(ConnectionCache::new("connection_cache_test")),
         bank_forks,
-        &Arc::new(PrioritizationFeeCache::new(0u64)),
+        None,
         false,
     );
 

core/benches/consumer.rs

@@ -83,7 +83,7 @@ fn create_transactions(bank: &Bank, num: usize) -> Vec<RuntimeTransaction<Saniti
 
 fn create_consumer(poh_recorder: &RwLock<PohRecorder>) -> Consumer {
     let (replay_vote_sender, _replay_vote_receiver) = unbounded();
-    let committer = Committer::new(None, replay_vote_sender, Arc::default());
+    let committer = Committer::new(None, replay_vote_sender, None);
     let transaction_recorder = poh_recorder.read().unwrap().new_recorder();
     Consumer::new(committer, transaction_recorder, QosService::new(0), None)
 }

core/src/banking_simulation.rs

@@ -31,7 +31,6 @@ use {
         bank::{Bank, HashOverrides},
         bank_forks::BankForks,
         installed_scheduler_pool::BankWithScheduler,
-        prioritization_fee_cache::PrioritizationFeeCache,
     },
     solana_sdk::{
         clock::{Slot, DEFAULT_MS_PER_SLOT, HOLD_TRANSACTIONS_SLOT_OFFSET},
@@ -800,7 +799,6 @@ impl BankingSimulator {
         let cluster_info = Arc::new(DummyClusterInfo {
             id: simulated_leader.into(),
         });
-        let prioritization_fee_cache = &Arc::new(PrioritizationFeeCache::new(0u64));
         let banking_stage = BankingStage::new_num_threads(
             block_production_method.clone(),
             &cluster_info,
@@ -814,7 +812,7 @@ impl BankingSimulator {
             None,
             connection_cache,
             bank_forks.clone(),
-            prioritization_fee_cache,
+            None,
             false,
         );
 

core/src/banking_stage.rs

@@ -360,7 +360,7 @@ impl BankingStage {
         log_messages_bytes_limit: Option<usize>,
         connection_cache: Arc<ConnectionCache>,
         bank_forks: Arc<RwLock<BankForks>>,
-        prioritization_fee_cache: &Arc<PrioritizationFeeCache>,
+        prioritization_fee_cache: Option<Arc<PrioritizationFeeCache>>,
         enable_forwarding: bool,
     ) -> Self {
         Self::new_num_threads(
@@ -395,7 +395,7 @@ impl BankingStage {
         log_messages_bytes_limit: Option<usize>,
         connection_cache: Arc<ConnectionCache>,
         bank_forks: Arc<RwLock<BankForks>>,
-        prioritization_fee_cache: &Arc<PrioritizationFeeCache>,
+        prioritization_fee_cache: Option<Arc<PrioritizationFeeCache>>,
         enable_forwarding: bool,
     ) -> Self {
         match block_production_method {
@@ -430,7 +430,7 @@ impl BankingStage {
         log_messages_bytes_limit: Option<usize>,
         connection_cache: Arc<ConnectionCache>,
         bank_forks: Arc<RwLock<BankForks>>,
-        prioritization_fee_cache: &Arc<PrioritizationFeeCache>,
+        prioritization_fee_cache: Option<Arc<PrioritizationFeeCache>>,
     ) -> Self {
         assert!(num_threads >= MIN_TOTAL_THREADS);
         // Single thread to generate entries from many banks.
@@ -449,7 +449,7 @@ impl BankingStage {
         let committer = Committer::new(
             transaction_status_sender.clone(),
             replay_vote_sender.clone(),
-            prioritization_fee_cache.clone(),
+            prioritization_fee_cache,
         );
         let transaction_recorder = poh_recorder.read().unwrap().new_recorder();
 
@@ -516,7 +516,7 @@ impl BankingStage {
         log_messages_bytes_limit: Option<usize>,
         connection_cache: Arc<ConnectionCache>,
         bank_forks: Arc<RwLock<BankForks>>,
-        prioritization_fee_cache: &Arc<PrioritizationFeeCache>,
+        prioritization_fee_cache: Option<Arc<PrioritizationFeeCache>>,
         enable_forwarding: bool,
     ) -> Self {
         assert!(num_threads >= MIN_TOTAL_THREADS);
@@ -534,7 +534,7 @@ impl BankingStage {
         let committer = Committer::new(
             transaction_status_sender.clone(),
             replay_vote_sender.clone(),
-            prioritization_fee_cache.clone(),
+            prioritization_fee_cache,
         );
         let transaction_recorder = poh_recorder.read().unwrap().new_recorder();
 
@@ -900,7 +900,7 @@ mod tests {
                 None,
                 Arc::new(ConnectionCache::new("connection_cache_test")),
                 bank_forks,
-                &Arc::new(PrioritizationFeeCache::new(0u64)),
+                None,
                 false,
             );
             drop(non_vote_sender);
@@ -960,7 +960,7 @@ mod tests {
                 None,
                 Arc::new(ConnectionCache::new("connection_cache_test")),
                 bank_forks,
-                &Arc::new(PrioritizationFeeCache::new(0u64)),
+                None,
                 false,
             );
             trace!("sending bank");
@@ -1044,7 +1044,7 @@ mod tests {
                 None,
                 Arc::new(ConnectionCache::new("connection_cache_test")),
                 bank_forks.clone(), // keep a local-copy of bank-forks so worker threads do not lose weak access to bank-forks
-                &Arc::new(PrioritizationFeeCache::new(0u64)),
+                None,
                 false,
             );
 
@@ -1214,7 +1214,7 @@ mod tests {
                     None,
                     Arc::new(ConnectionCache::new("connection_cache_test")),
                     bank_forks,
-                    &Arc::new(PrioritizationFeeCache::new(0u64)),
+                    None,
                 );
 
                 // wait for banking_stage to eat the packets
@@ -1409,7 +1409,7 @@ mod tests {
                 None,
                 Arc::new(ConnectionCache::new("connection_cache_test")),
                 bank_forks,
-                &Arc::new(PrioritizationFeeCache::new(0u64)),
+                None,
                 false,
             );
 

core/src/banking_stage/committer.rs

@@ -46,14 +46,14 @@ pub(super) struct PreBalanceInfo {
 pub struct Committer {
     transaction_status_sender: Option<TransactionStatusSender>,
     replay_vote_sender: ReplayVoteSender,
-    prioritization_fee_cache: Arc<PrioritizationFeeCache>,
+    prioritization_fee_cache: Option<Arc<PrioritizationFeeCache>>,
 }
 
 impl Committer {
     pub fn new(
         transaction_status_sender: Option<TransactionStatusSender>,
         replay_vote_sender: ReplayVoteSender,
-        prioritization_fee_cache: Arc<PrioritizationFeeCache>,
+        prioritization_fee_cache: Option<Arc<PrioritizationFeeCache>>,
     ) -> Self {
         Self {
             transaction_status_sender,
@@ -119,8 +119,10 @@ impl Committer {
                 pre_balance_info,
                 starting_transaction_index,
             );
-            self.prioritization_fee_cache
-                .update(bank, processed_transactions.into_iter());
+
+            if let Some(prioritization_fee_cache) = self.prioritization_fee_cache.as_ref() {
+                prioritization_fee_cache.update(bank, processed_transactions.into_iter());
+            }
         });
         execute_and_commit_timings.find_and_send_votes_us = find_and_send_votes_us;
         (commit_time_us, commit_transaction_statuses)

core/src/banking_stage/consume_worker.rs

@@ -764,10 +764,7 @@ mod tests {
             get_tmp_ledger_path_auto_delete, leader_schedule_cache::LeaderScheduleCache,
         },
         solana_poh::poh_recorder::{PohRecorder, WorkingBankEntry},
-        solana_runtime::{
-            bank_forks::BankForks, prioritization_fee_cache::PrioritizationFeeCache,
-            vote_sender_types::ReplayVoteReceiver,
-        },
+        solana_runtime::{bank_forks::BankForks, vote_sender_types::ReplayVoteReceiver},
         solana_runtime_transaction::runtime_transaction::RuntimeTransaction,
         solana_sdk::{
             address_lookup_table::AddressLookupTableAccount,
@@ -848,11 +845,7 @@ mod tests {
         let poh_simulator = simulate_poh(record_receiver, &poh_recorder);
 
         let (replay_vote_sender, replay_vote_receiver) = unbounded();
-        let committer = Committer::new(
-            None,
-            replay_vote_sender,
-            Arc::new(PrioritizationFeeCache::new(0u64)),
-        );
+        let committer = Committer::new(None, replay_vote_sender, None);
         let consumer = Consumer::new(committer, recorder, QosService::new(1), None);
 
         let (consume_sender, consume_receiver) = unbounded();