Remove Bank events as it's not needed anymore

Author: ryoqun

core/benches/banking_stage.rs

@@ -102,7 +102,7 @@ fn bench_consume_buffered(bencher: &mut Bencher) {
                 &BankingStageStats::default(),
                 &recorder,
                 &QosService::new(1),
-                &mut LeaderSlotMetricsTracker::new_for_test(),
+                &mut LeaderSlotMetricsTracker::new(0),
                 None,
             );
         });

core/src/banking_stage.rs

@@ -488,7 +488,6 @@ impl BankingStage {
                 let data_budget = data_budget.clone();
                 let connection_cache = connection_cache.clone();
                 let bank_forks = bank_forks.clone();
-                let banking_tracer = banking_tracer.clone();
                 Builder::new()
                     .name(format!("solBanknStgTx{i:02}"))
                     .spawn(move || {
@@ -505,7 +504,6 @@ impl BankingStage {
                             connection_cache,
                             &bank_forks,
                             unprocessed_transaction_storage,
-                            banking_tracer,
                         );
                     })
                     .unwrap()
@@ -794,7 +792,6 @@ impl BankingStage {
         my_pubkey: &Pubkey,
         poh_recorder: &RwLock<PohRecorder>,
         slot_metrics_tracker: &mut LeaderSlotMetricsTracker,
-        unprocessed_transaction_count: usize,
     ) -> (MetricsTrackerAction, BufferedPacketsDecision) {
         let (leader_at_slot_offset, bank_start, would_be_leader, would_be_leader_shortly) = {
             let poh = poh_recorder.read().unwrap();
@@ -811,7 +808,6 @@ impl BankingStage {
             )
         };
 
-        slot_metrics_tracker.refresh_unprocessed_transaction_count(unprocessed_transaction_count);
         (
             slot_metrics_tracker.check_leader_slot_boundary(&bank_start),
             Self::consume_or_forward_packets(
@@ -846,13 +842,9 @@ impl BankingStage {
         if unprocessed_transaction_storage.should_not_process() {
             return;
         }
-        let ((metrics_action, decision), make_decision_time) =
-            measure!(Self::make_consume_or_forward_decision(
-                my_pubkey,
-                poh_recorder,
-                slot_metrics_tracker,
-                unprocessed_transaction_storage.len(),
-            ));
+        let ((metrics_action, decision), make_decision_time) = measure!(
+            Self::make_consume_or_forward_decision(my_pubkey, poh_recorder, slot_metrics_tracker,)
+        );
         slot_metrics_tracker.increment_make_decision_us(make_decision_time.as_us());
 
         match decision {
@@ -923,9 +915,7 @@ impl BankingStage {
                 // Take metrics action after forwarding packets
                 slot_metrics_tracker.apply_action(metrics_action);
             }
-            BufferedPacketsDecision::Hold => {
-                slot_metrics_tracker.apply_action(metrics_action);
-            }
+            _ => {}
         }
     }
 
@@ -1040,15 +1030,14 @@ impl BankingStage {
         connection_cache: Arc<ConnectionCache>,
         bank_forks: &Arc<RwLock<BankForks>>,
         mut unprocessed_transaction_storage: UnprocessedTransactionStorage,
-        banking_tracer: Arc<BankingTracer>,
     ) {
         let recorder = poh_recorder.read().unwrap().recorder();
         let socket = UdpSocket::bind("0.0.0.0:0").unwrap();
         let mut banking_stage_stats = BankingStageStats::new(id);
         let mut tracer_packet_stats = TracerPacketStats::new(id);
         let qos_service = QosService::new(id);
 
-        let mut slot_metrics_tracker = LeaderSlotMetricsTracker::new(id, banking_tracer);
+        let mut slot_metrics_tracker = LeaderSlotMetricsTracker::new(id);
         let mut last_metrics_update = Instant::now();
 
         loop {
@@ -3710,7 +3699,7 @@ mod tests {
                 &BankingStageStats::default(),
                 &recorder,
                 &QosService::new(1),
-                &mut LeaderSlotMetricsTracker::new_for_test(),
+                &mut LeaderSlotMetricsTracker::new(0),
                 None,
             );
             assert!(buffered_packet_batches.is_empty());
@@ -3768,7 +3757,7 @@ mod tests {
                 &BankingStageStats::default(),
                 &recorder,
                 &QosService::new(1),
-                &mut LeaderSlotMetricsTracker::new_for_test(),
+                &mut LeaderSlotMetricsTracker::new(0),
                 None,
             );
             assert!(buffered_packet_batches.is_empty());
@@ -3830,7 +3819,7 @@ mod tests {
                         &BankingStageStats::default(),
                         &recorder,
                         &QosService::new(1),
-                        &mut LeaderSlotMetricsTracker::new_for_test(),
+                        &mut LeaderSlotMetricsTracker::new(0),
                         None,
                     );
 
@@ -3926,7 +3915,7 @@ mod tests {
                     &socket,
                     true,
                     &data_budget,
-                    &mut LeaderSlotMetricsTracker::new_for_test(),
+                    &mut LeaderSlotMetricsTracker::new(0),
                     &stats,
                     &connection_cache,
                     &mut TracerPacketStats::new(0),
@@ -4026,7 +4015,7 @@ mod tests {
                     &socket,
                     hold,
                     &DataBudget::default(),
-                    &mut LeaderSlotMetricsTracker::new_for_test(),
+                    &mut LeaderSlotMetricsTracker::new(0),
                     &stats,
                     &connection_cache,
                     &mut TracerPacketStats::new(0),

core/src/banking_trace.rs

@@ -71,7 +71,6 @@ pub struct TimedTracedEvent(std::time::SystemTime, TracedEvent);
 #[derive(Serialize, Deserialize, Debug)]
 enum TracedEvent {
     PacketBatch(ChannelLabel, BankingPacketBatch),
-    Bank(Slot, u32, BankStatus, usize),
     BlockAndBankHash(Slot, Hash, Hash),
 }
 
@@ -251,19 +250,6 @@ impl BankingTracer {
         })
     }
 
-    fn bank_event(
-        &self,
-        slot: Slot,
-        id: u32,
-        status: BankStatus,
-        unprocessed_transaction_count: usize,
-    ) {
-        self.trace_event(TimedTracedEvent(
-            SystemTime::now(),
-            TracedEvent::Bank(slot, id, status, unprocessed_transaction_count),
-        ))
-    }
-
     pub fn hash_event(&self, slot: Slot, blockhash: Hash, bank_hash: Hash) {
         self.trace_event(TimedTracedEvent(
             SystemTime::now(),
@@ -281,14 +267,6 @@ impl BankingTracer {
         }
     }
 
-    pub fn bank_start(&self, slot: Slot, id: u32, unprocessed_transaction_count: usize) {
-        self.bank_event(slot, id, BankStatus::Started, unprocessed_transaction_count);
-    }
-
-    pub fn bank_end(&self, slot: Slot, id: u32, unprocessed_transaction_count: usize) {
-        self.bank_event(slot, id, BankStatus::Ended, unprocessed_transaction_count);
-    }
-
     pub fn channel_for_test() -> (TracedSender, Receiver<BankingPacketBatch>) {
         Self::channel(ChannelLabel::Dummy, None)
     }
@@ -490,7 +468,9 @@ mod tests {
         tracer_thread.unwrap().join().unwrap().unwrap();
 
         // shouldn't panic
-        tracer.bank_end(1, 2, 3);
+        let blockhash = Hash::from_str("B1ockhash1111111111111111111111111111111111").unwrap();
+        let bank_hash = Hash::from_str("BankHash11111111111111111111111111111111111").unwrap();
+        tracer.hash_event(4, blockhash, bank_hash);
 
         drop(tracer);
 
@@ -528,7 +508,6 @@ mod tests {
         non_vote_sender
             .send(for_test::sample_packet_batch())
             .unwrap();
-        tracer.bank_start(1, 2, 3);
         let blockhash = Hash::from_str("B1ockhash1111111111111111111111111111111111").unwrap();
         let bank_hash = Hash::from_str("BankHash11111111111111111111111111111111111").unwrap();
         tracer.hash_event(4, blockhash, bank_hash);
@@ -549,14 +528,6 @@ mod tests {
             ))
         );
         i += 1;
-        assert_matches!(
-            results[i],
-            Ok(TimedTracedEvent(
-                _,
-                TracedEvent::Bank(1, 2, BankStatus::Started, 3)
-            ))
-        );
-        i += 1;
         assert_matches!(
             results[i],
             Ok(TimedTracedEvent(

core/src/leader_slot_banking_stage_metrics.rs

@@ -1,12 +1,12 @@
 use {
     crate::{
-        banking_trace::BankingTracer, leader_slot_banking_stage_timing_metrics::*,
+        leader_slot_banking_stage_timing_metrics::*,
         unprocessed_transaction_storage::InsertPacketBatchSummary,
     },
     solana_poh::poh_recorder::BankStart,
     solana_runtime::transaction_error_metrics::*,
     solana_sdk::{clock::Slot, saturating_add_assign},
-    std::{sync::Arc, time::Instant},
+    std::time::Instant,
 };
 
 /// A summary of what happened to transactions passed to the execution pipeline.
@@ -358,45 +358,16 @@ pub struct LeaderSlotMetricsTracker {
     // otherwise `None`
     leader_slot_metrics: Option<LeaderSlotMetrics>,
     id: u32,
-    banking_tracer: Arc<BankingTracer>,
-    unprocessed_transaction_count: usize,
 }
 
 impl LeaderSlotMetricsTracker {
-    pub fn new(id: u32, banking_tracer: Arc<BankingTracer>) -> Self {
+    pub fn new(id: u32) -> Self {
         Self {
             leader_slot_metrics: None,
             id,
-            banking_tracer,
-            unprocessed_transaction_count: 0,
         }
     }
 
-    pub fn refresh_unprocessed_transaction_count(&mut self, batch_count: usize) {
-        self.unprocessed_transaction_count = batch_count;
-    }
-
-    pub fn new_for_test() -> Self {
-        Self::new(0, BankingTracer::new_disabled())
-    }
-
-    fn create_new_slot_metrics(&self, bank_start: &BankStart) -> Option<LeaderSlotMetrics> {
-        let metrics = LeaderSlotMetrics::new(
-            self.id,
-            bank_start.working_bank.slot(),
-            &bank_start.bank_creation_time,
-        );
-        self.banking_tracer
-            .bank_start(metrics.slot, self.id, self.unprocessed_transaction_count);
-
-        Some(metrics)
-    }
-
-    pub fn trace_bank_end(&self, metrics_slot: Slot) {
-        self.banking_tracer
-            .bank_end(metrics_slot, self.id, self.unprocessed_transaction_count);
-    }
-
     // Check leader slot, return MetricsTrackerAction to be applied by apply_action()
     pub(crate) fn check_leader_slot_boundary(
         &mut self,
@@ -406,27 +377,28 @@ impl LeaderSlotMetricsTracker {
             (None, None) => MetricsTrackerAction::Noop,
 
             (Some(leader_slot_metrics), None) => {
-                let slot = leader_slot_metrics.slot;
                 leader_slot_metrics.mark_slot_end_detected();
-                self.trace_bank_end(slot);
-
                 MetricsTrackerAction::ReportAndResetTracker
             }
 
             // Our leader slot has begain, time to create a new slot tracker
             (None, Some(bank_start)) => {
-                MetricsTrackerAction::NewTracker(self.create_new_slot_metrics(bank_start))
+                MetricsTrackerAction::NewTracker(Some(LeaderSlotMetrics::new(
+                    self.id,
+                    bank_start.working_bank.slot(),
+                    &bank_start.bank_creation_time,
+                )))
             }
 
             (Some(leader_slot_metrics), Some(bank_start)) => {
                 if leader_slot_metrics.slot != bank_start.working_bank.slot() {
                     // Last slot has ended, new slot has began
-                    let slot = leader_slot_metrics.slot;
                     leader_slot_metrics.mark_slot_end_detected();
-                    self.trace_bank_end(slot);
-                    MetricsTrackerAction::ReportAndNewTracker(
-                        self.create_new_slot_metrics(bank_start),
-                    )
+                    MetricsTrackerAction::ReportAndNewTracker(Some(LeaderSlotMetrics::new(
+                        self.id,
+                        bank_start.working_bank.slot(),
+                        &bank_start.bank_creation_time,
+                    )))
                 } else {
                     MetricsTrackerAction::Noop
                 }
@@ -905,7 +877,8 @@ mod tests {
             bank_creation_time: Arc::new(Instant::now()),
         };
 
-        let leader_slot_metrics_tracker = LeaderSlotMetricsTracker::new_for_test();
+        let banking_stage_thread_id = 0;
+        let leader_slot_metrics_tracker = LeaderSlotMetricsTracker::new(banking_stage_thread_id);
 
         TestSlotBoundaryComponents {
             first_bank,