Rename types and metrics from executed to processed (#2435)

core/src/banking_stage/committer.rs

@@ -6,7 +6,7 @@ use {
     },
     solana_measure::measure_us,
     solana_runtime::{
-        bank::{Bank, ExecutedTransactionCounts, TransactionBalancesSet},
+        bank::{Bank, ProcessedTransactionCounts, TransactionBalancesSet},
         bank_utils,
         prioritization_fee_cache::PrioritizationFeeCache,
         transaction_batch::TransactionBatch,
@@ -15,7 +15,9 @@ use {
     solana_sdk::{hash::Hash, pubkey::Pubkey, saturating_add_assign},
     solana_svm::{
         transaction_commit_result::{TransactionCommitResult, TransactionCommitResultExtensions},
-        transaction_execution_result::TransactionExecutionResult,
+        transaction_processing_result::{
+            TransactionProcessingResult, TransactionProcessingResultExtensions,
+        },
     },
     solana_transaction_status::{
         token_balances::TransactionTokenBalancesSet, TransactionTokenBalance,
@@ -67,27 +69,27 @@ impl Committer {
     pub(super) fn commit_transactions(
         &self,
         batch: &TransactionBatch,
-        execution_results: Vec<TransactionExecutionResult>,
+        processing_results: Vec<TransactionProcessingResult>,
         last_blockhash: Hash,
         lamports_per_signature: u64,
         starting_transaction_index: Option<usize>,
         bank: &Arc<Bank>,
         pre_balance_info: &mut PreBalanceInfo,
         execute_and_commit_timings: &mut LeaderExecuteAndCommitTimings,
-        execution_counts: &ExecutedTransactionCounts,
+        processed_counts: &ProcessedTransactionCounts,
     ) -> (u64, Vec<CommitTransactionDetails>) {
-        let executed_transactions = execution_results
+        let processed_transactions = processing_results
             .iter()
             .zip(batch.sanitized_transactions())
-            .filter_map(|(execution_result, tx)| execution_result.was_executed().then_some(tx))
+            .filter_map(|(processing_result, tx)| processing_result.was_processed().then_some(tx))
             .collect_vec();
 
         let (commit_results, commit_time_us) = measure_us!(bank.commit_transactions(
             batch.sanitized_transactions(),
-            execution_results,
+            processing_results,
             last_blockhash,
             lamports_per_signature,
-            execution_counts,
+            processed_counts,
             &mut execute_and_commit_timings.execute_timings,
         ));
         execute_and_commit_timings.commit_us = commit_time_us;
@@ -122,7 +124,7 @@ impl Committer {
                 starting_transaction_index,
             );
             self.prioritization_fee_cache
-                .update(bank, executed_transactions.into_iter());
+                .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)
@@ -145,7 +147,7 @@ impl Committer {
             let batch_transaction_indexes: Vec<_> = commit_results
                 .iter()
                 .map(|commit_result| {
-                    if commit_result.was_executed() {
+                    if commit_result.was_committed() {
                         let this_transaction_index = transaction_index;
                         saturating_add_assign!(transaction_index, 1);
                         this_transaction_index

core/src/banking_stage/consume_worker.rs

@@ -234,18 +234,18 @@ impl ConsumeWorkerMetrics {
         }: &ExecuteAndCommitTransactionsOutput,
     ) {
         self.count_metrics
-            .transactions_attempted_execution_count
+            .transactions_attempted_processing_count
             .fetch_add(
-                transaction_counts.attempted_execution_count,
+                transaction_counts.attempted_processing_count,
                 Ordering::Relaxed,
             );
         self.count_metrics
-            .executed_transactions_count
-            .fetch_add(transaction_counts.executed_count, Ordering::Relaxed);
+            .processed_transactions_count
+            .fetch_add(transaction_counts.processed_count, Ordering::Relaxed);
         self.count_metrics
-            .executed_with_successful_result_count
+            .processed_with_successful_result_count
             .fetch_add(
-                transaction_counts.executed_with_successful_result_count,
+                transaction_counts.processed_with_successful_result_count,
                 Ordering::Relaxed,
             );
         self.count_metrics
@@ -410,9 +410,9 @@ impl ConsumeWorkerMetrics {
 }
 
 struct ConsumeWorkerCountMetrics {
-    transactions_attempted_execution_count: AtomicU64,
-    executed_transactions_count: AtomicU64,
-    executed_with_successful_result_count: AtomicU64,
+    transactions_attempted_processing_count: AtomicU64,
+    processed_transactions_count: AtomicU64,
+    processed_with_successful_result_count: AtomicU64,
     retryable_transaction_count: AtomicUsize,
     retryable_expired_bank_count: AtomicUsize,
     cost_model_throttled_transactions_count: AtomicU64,
@@ -423,9 +423,9 @@ struct ConsumeWorkerCountMetrics {
 impl Default for ConsumeWorkerCountMetrics {
     fn default() -> Self {
         Self {
-            transactions_attempted_execution_count: AtomicU64::default(),
-            executed_transactions_count: AtomicU64::default(),
-            executed_with_successful_result_count: AtomicU64::default(),
+            transactions_attempted_processing_count: AtomicU64::default(),
+            processed_transactions_count: AtomicU64::default(),
+            processed_with_successful_result_count: AtomicU64::default(),
             retryable_transaction_count: AtomicUsize::default(),
             retryable_expired_bank_count: AtomicUsize::default(),
             cost_model_throttled_transactions_count: AtomicU64::default(),
@@ -441,19 +441,19 @@ impl ConsumeWorkerCountMetrics {
             "banking_stage_worker_counts",
             "id" => id,
             (
-                "transactions_attempted_execution_count",
-                self.transactions_attempted_execution_count
+                "transactions_attempted_processing_count",
+                self.transactions_attempted_processing_count
                     .swap(0, Ordering::Relaxed),
                 i64
             ),
             (
-                "executed_transactions_count",
-                self.executed_transactions_count.swap(0, Ordering::Relaxed),
+                "processed_transactions_count",
+                self.processed_transactions_count.swap(0, Ordering::Relaxed),
                 i64
             ),
             (
-                "executed_with_successful_result_count",
-                self.executed_with_successful_result_count
+                "processed_with_successful_result_count",
+                self.processed_with_successful_result_count
                     .swap(0, Ordering::Relaxed),
                 i64
             ),