Metrics prioritization fees

core/src/banking_stage.rs

@@ -659,7 +659,10 @@ impl BankingStage {
         }
         let (decision, make_decision_time) =
             measure!(decision_maker.make_consume_or_forward_decision());
-        let metrics_action = slot_metrics_tracker.check_leader_slot_boundary(decision.bank_start());
+        let metrics_action = slot_metrics_tracker.check_leader_slot_boundary(
+            decision.bank_start(),
+            Some(unprocessed_transaction_storage),
+        );
         slot_metrics_tracker.increment_make_decision_us(make_decision_time.as_us());
 
         match decision {

core/src/banking_stage/consume_worker.rs

@@ -212,6 +212,8 @@ impl ConsumeWorkerMetrics {
             retryable_transaction_indexes,
             execute_and_commit_timings,
             error_counters,
+            min_prioritization_fees,
+            max_prioritization_fees,
             ..
         }: &ExecuteAndCommitTransactionsOutput,
     ) {
@@ -227,7 +229,20 @@ impl ConsumeWorkerMetrics {
         self.count_metrics
             .retryable_transaction_count
             .fetch_add(retryable_transaction_indexes.len(), Ordering::Relaxed);
-
+        let min_prioritization_fees = self
+            .count_metrics
+            .min_prioritization_fees
+            .fetch_min(*min_prioritization_fees, Ordering::Relaxed);
+        let max_prioritization_fees = self
+            .count_metrics
+            .max_prioritization_fees
+            .fetch_max(*max_prioritization_fees, Ordering::Relaxed);
+        self.count_metrics
+            .min_prioritization_fees
+            .swap(min_prioritization_fees, Ordering::Relaxed);
+        self.count_metrics
+            .max_prioritization_fees
+            .swap(max_prioritization_fees, Ordering::Relaxed);
         self.update_on_execute_and_commit_timings(execute_and_commit_timings);
         self.update_on_error_counters(error_counters);
     }
@@ -368,14 +383,30 @@ impl ConsumeWorkerMetrics {
     }
 }
 
-#[derive(Default)]
 struct ConsumeWorkerCountMetrics {
     transactions_attempted_execution_count: AtomicUsize,
     executed_transactions_count: AtomicUsize,
     executed_with_successful_result_count: AtomicUsize,
     retryable_transaction_count: AtomicUsize,
     retryable_expired_bank_count: AtomicUsize,
     cost_model_throttled_transactions_count: AtomicUsize,
+    min_prioritization_fees: AtomicU64,
+    max_prioritization_fees: AtomicU64,
+}
+
+impl Default for ConsumeWorkerCountMetrics {
+    fn default() -> Self {
+        Self {
+            min_prioritization_fees: AtomicU64::new(u64::MAX),
+            transactions_attempted_execution_count: AtomicUsize::default(),
+            executed_transactions_count: AtomicUsize::default(),
+            executed_with_successful_result_count: AtomicUsize::default(),
+            retryable_transaction_count: AtomicUsize::default(),
+            retryable_expired_bank_count: AtomicUsize::default(),
+            cost_model_throttled_transactions_count: AtomicUsize::default(),
+            max_prioritization_fees: AtomicU64::default(),
+        }
+    }
 }
 
 impl ConsumeWorkerCountMetrics {
@@ -416,6 +447,16 @@ impl ConsumeWorkerCountMetrics {
                     .swap(0, Ordering::Relaxed),
                 i64
             ),
+            (
+                "min_prioritization_fees",
+                self.min_prioritization_fees.swap(0, Ordering::Relaxed),
+                i64
+            ),
+            (
+                "max_prioritization_fees",
+                self.max_prioritization_fees.swap(0, Ordering::Relaxed),
+                i64
+            ),
         );
     }
 }

core/src/banking_stage/consumer.rs

@@ -23,6 +23,7 @@ use {
     solana_runtime::{
         bank::{Bank, LoadAndExecuteTransactionsOutput},
         transaction_batch::TransactionBatch,
+        transaction_priority_details::GetTransactionPriorityDetails,
     },
     solana_sdk::{
         clock::{Slot, FORWARD_TRANSACTIONS_TO_LEADER_AT_SLOT_OFFSET, MAX_PROCESSING_AGE},
@@ -64,6 +65,8 @@ pub struct ExecuteAndCommitTransactionsOutput {
     pub commit_transactions_result: Result<Vec<CommitTransactionDetails>, PohRecorderError>,
     pub(crate) execute_and_commit_timings: LeaderExecuteAndCommitTimings,
     pub(crate) error_counters: TransactionErrorMetrics,
+    pub(crate) min_prioritization_fees: u64,
+    pub(crate) max_prioritization_fees: u64,
 }
 
 pub struct Consumer {
@@ -286,6 +289,8 @@ impl Consumer {
         let mut total_execute_and_commit_timings = LeaderExecuteAndCommitTimings::default();
         let mut total_error_counters = TransactionErrorMetrics::default();
         let mut reached_max_poh_height = false;
+        let mut overall_min_prioritization_fees: u64 = u64::MAX;
+        let mut overall_max_prioritization_fees: u64 = 0;
         while chunk_start != transactions.len() {
             let chunk_end = std::cmp::min(
                 transactions.len(),
@@ -316,6 +321,8 @@ impl Consumer {
                 commit_transactions_result: new_commit_transactions_result,
                 execute_and_commit_timings: new_execute_and_commit_timings,
                 error_counters: new_error_counters,
+                min_prioritization_fees,
+                max_prioritization_fees,
                 ..
             } = execute_and_commit_transactions_output;
 
@@ -325,6 +332,10 @@ impl Consumer {
                 total_transactions_attempted_execution_count,
                 new_transactions_attempted_execution_count
             );
+            overall_min_prioritization_fees =
+                std::cmp::min(overall_min_prioritization_fees, min_prioritization_fees);
+            overall_max_prioritization_fees =
+                std::cmp::min(overall_max_prioritization_fees, max_prioritization_fees);
 
             trace!(
                 "process_transactions result: {:?}",
@@ -385,6 +396,8 @@ impl Consumer {
             cost_model_us: total_cost_model_us,
             execute_and_commit_timings: total_execute_and_commit_timings,
             error_counters: total_error_counters,
+            min_prioritization_fees: overall_min_prioritization_fees,
+            max_prioritization_fees: overall_max_prioritization_fees,
         }
     }
 
@@ -545,6 +558,19 @@ impl Consumer {
         });
         execute_and_commit_timings.collect_balances_us = collect_balances_us;
 
+        let min_max = batch
+            .sanitized_transactions()
+            .iter()
+            .filter_map(|transaction| {
+                let round_compute_unit_price_enabled = false; // TODO get from working_bank.feature_set
+                transaction
+                    .get_transaction_priority_details(round_compute_unit_price_enabled)
+                    .map(|details| details.priority)
+            })
+            .minmax();
+        let (min_prioritization_fees, max_prioritization_fees) =
+            min_max.into_option().unwrap_or_default();
+
         let (load_and_execute_transactions_output, load_execute_us) = measure_us!(bank
             .load_and_execute_transactions(
                 batch,
@@ -626,6 +652,8 @@ impl Consumer {
                 commit_transactions_result: Err(recorder_err),
                 execute_and_commit_timings,
                 error_counters,
+                min_prioritization_fees,
+                max_prioritization_fees,
             };
         }
 
@@ -681,6 +709,8 @@ impl Consumer {
             commit_transactions_result: Ok(commit_transaction_statuses),
             execute_and_commit_timings,
             error_counters,
+            min_prioritization_fees,
+            max_prioritization_fees,
         }
     }