Bench execute batch no more overhead hacks

accounts-db/src/accounts_db.rs

@@ -5118,7 +5118,7 @@ impl AccountsDb {
         ancestors: &Ancestors,
         pubkey: &Pubkey,
     ) -> Option<(AccountSharedData, Slot)> {
-        self.load(ancestors, pubkey, LoadHint::FixedMaxRoot)
+        Some((AccountSharedData::new(1111111, 0, &Default::default()), 3))//self.load(ancestors, pubkey, LoadHint::FixedMaxRoot)
     }
 
     fn read_index_for_accessor_or_load_slow<'a>(

ledger/Cargo.toml

@@ -33,6 +33,7 @@ rand = { workspace = true }
 rand_chacha = { workspace = true }
 rayon = { workspace = true }
 reed-solomon-erasure = { workspace = true, features = ["simd-accel"] }
+rustix = { version = "0.38.28", features = ["thread"] }
 scopeguard = { workspace = true }
 serde = { workspace = true }
 serde_bytes = { workspace = true }

ledger/benches/blockstore_processor.rs

@@ -23,6 +23,7 @@ use {
     std::{borrow::Cow, sync::Arc},
     test::Bencher,
 };
+use solana_ledger::blockstore_processor::execute_batch2;
 
 extern crate test;
 
@@ -112,65 +113,149 @@ fn bench_execute_batch(
         bank,
         prioritization_fee_cache,
     } = setup(apply_cost_tracker_during_replay);
-    let transactions = create_transactions(&bank, 2_usize.pow(20));
+    let transactions = create_transactions(&bank, 2_usize.pow(19));
+    let bank2 = bank.clone();
     let batches: Vec<_> = transactions
         .chunks(batch_size)
         .map(|txs| {
             let mut batch =
-                TransactionBatch::new(vec![Ok(()); txs.len()], &bank, Cow::Borrowed(txs));
+                TransactionBatch::new(vec![Ok(()); txs.len()], &bank2, Cow::Borrowed(txs));
             batch.set_needs_unlock(false);
             TransactionBatchWithIndexes {
                 batch,
                 transaction_indexes: (0..batch_size).collect(),
             }
         })
         .collect();
-    let mut batches_iter = batches.into_iter();
+    let mut batches_iter = batches.iter();
 
     let mut timing = ExecuteTimings::default();
-    bencher.iter({
-        let bank = bank.clone();
-        move || {
-            let batch = batches_iter.next().unwrap();
-            execute_batch(
-                &batch,
-                &bank,
-                None,
-                None,
-                &mut timing,
-                None,
-                &prioritization_fee_cache,
-            )
-        }
+    let batch = batches_iter.next().unwrap();
+
+    std::thread::scope(move |scope| {
+        scope.spawn(move || {
+            //eprintln!("profile me!: {}", rustix::thread::gettid().as_raw_nonzero().get());
+            //std::thread::sleep(std::time::Duration::from_secs(10));
+            bencher.iter(|| {
+            //for _ in 0..3 {
+            //let now = std::time::Instant::now();
+            //let iteration_count_for_profiling = 100;
+            //for _ in 0..iteration_count_for_profiling {
+                for _ in 0..(64/batch_size) {
+                    execute_batch(
+                        &batch,
+                        &bank,
+                        None,
+                        None,
+                        &mut timing,
+                        None,
+                        &prioritization_fee_cache,
+                    ).unwrap();
+                }
+            //}
+            });
+            //dbg!(now.elapsed());
+            //}
+        });
+    });
+    drop(batches);
+    //eprintln!("{:?}", timing);
+}
+
+fn bench_execute_batch2(
+    bencher: &mut Bencher,
+    batch_size: usize,
+    apply_cost_tracker_during_replay: bool,
+) {
+    let BenchFrame {
+        bank,
+        prioritization_fee_cache,
+    } = setup(apply_cost_tracker_during_replay);
+    let transactions = create_transactions(&bank, 2_usize.pow(19));
+    let bank2 = bank.clone();
+    let batches: Vec<_> = transactions
+        .chunks(batch_size)
+        .map(|txs| {
+            let mut batch =
+                TransactionBatch::new(vec![Ok(()); txs.len()], &bank2, Cow::Borrowed(txs));
+            batch.set_needs_unlock(false);
+            TransactionBatchWithIndexes {
+                batch,
+                transaction_indexes: (0..batch_size).collect(),
+            }
+        })
+        .collect();
+    let mut batches_iter = batches.iter();
+
+    let mut timing = ExecuteTimings::default();
+    let batch = batches_iter.next().unwrap();
+
+    std::thread::scope(move |scope| {
+        scope.spawn(move || {
+            //eprintln!("profile me!: {}", rustix::thread::gettid().as_raw_nonzero().get());
+            //std::thread::sleep(std::time::Duration::from_secs(10));
+            bencher.iter(|| {
+            //for _ in 0..3 {
+            //let now = std::time::Instant::now();
+            //let iteration_count_for_profiling = 100;
+            //for _ in 0..iteration_count_for_profiling {
+                for _ in 0..(64/batch_size) {
+                    execute_batch2(
+                        &batch,
+                        &bank,
+                        None,
+                        None,
+                        &mut timing,
+                        None,
+                        &prioritization_fee_cache,
+                    ).unwrap();
+                }
+            //}
+            });
+            //dbg!(now.elapsed());
+            //}
+        });
     });
+    drop(batches);
+    //eprintln!("{:?}", timing);
+}
+
+#[bench]
+fn bench_execute_batch_01_txes_per_batch(bencher: &mut Bencher) {
+    bench_execute_batch(bencher, 1, false);
 }
 
 #[bench]
-fn bench_execute_batch_unbatched(bencher: &mut Bencher) {
-    bench_execute_batch(bencher, 1, true);
+fn bench_execute_batch_04_txes_per_batch(bencher: &mut Bencher) {
+    bench_execute_batch(bencher, 4, false);
 }
 
 #[bench]
-fn bench_execute_batch_half_batch(bencher: &mut Bencher) {
-    bench_execute_batch(bencher, 32, true);
+fn bench_execute_batch_16_txes_per_batch(bencher: &mut Bencher) {
+    bench_execute_batch(bencher, 16, false);
 }
 
 #[bench]
-fn bench_execute_batch_full_batch(bencher: &mut Bencher) {
-    bench_execute_batch(bencher, 64, true);
+fn bench_execute_batch_64_txes_per_batch(bencher: &mut Bencher) {
+    bench_execute_batch(bencher, 64, false);
 }
 
 #[bench]
-fn bench_execute_batch_unbatched_disable_tx_cost_update(bencher: &mut Bencher) {
-    bench_execute_batch(bencher, 1, false);
+fn bench_execute_batch_flattend_01_txes_per_batch(bencher: &mut Bencher) {
+    bench_execute_batch2(bencher, 1, false);
 }
 
 #[bench]
-fn bench_execute_batch_half_batch_disable_tx_cost_update(bencher: &mut Bencher) {
-    bench_execute_batch(bencher, 32, false);
+fn bench_execute_batch_flattend_04_txes_per_batch(bencher: &mut Bencher) {
+    bench_execute_batch2(bencher, 4, false);
 }
 
 #[bench]
-fn bench_execute_batch_full_batch_disable_tx_cost_update(bencher: &mut Bencher) {
-    bench_execute_batch(bencher, 64, false);
+fn bench_execute_batch_flattend_16_txes_per_batch(bencher: &mut Bencher) {
+    bench_execute_batch2(bencher, 16, false);
+}
+
+#[bench]
+fn bench_execute_batch_flattend_64_txes_per_batch(bencher: &mut Bencher) {
+    bench_execute_batch2(bencher, 64, false);
 }

ledger/src/blockstore_processor.rs

@@ -157,7 +157,7 @@ pub fn execute_batch(
         vec![]
     };
 
-    let (tx_results, balances) = batch.bank().load_execute_and_commit_transactions(
+    batch.bank().load_execute_and_commit_transactions(
         batch,
         MAX_PROCESSING_AGE,
         transaction_status_sender.is_some(),
@@ -168,51 +168,44 @@ pub fn execute_batch(
         log_messages_bytes_limit,
     );
 
-    bank_utils::find_and_send_votes(
-        batch.sanitized_transactions(),
-        &tx_results,
-        replay_vote_sender,
-    );
-
-    let TransactionResults {
-        fee_collection_results,
-        execution_results,
-        rent_debits,
-        ..
-    } = tx_results;
+    Ok(())
+}
 
-    let executed_transactions = execution_results
-        .iter()
-        .zip(batch.sanitized_transactions())
-        .filter_map(|(execution_result, tx)| execution_result.was_executed().then_some(tx))
-        .collect_vec();
+pub fn execute_batch2(
+    batch: &TransactionBatchWithIndexes,
+    bank: &Arc<Bank>,
+    transaction_status_sender: Option<&TransactionStatusSender>,
+    replay_vote_sender: Option<&ReplayVoteSender>,
+    timings: &mut ExecuteTimings,
+    log_messages_bytes_limit: Option<usize>,
+    prioritization_fee_cache: &PrioritizationFeeCache,
+) -> Result<()> {
+    let TransactionBatchWithIndexes {
+        batch,
+        transaction_indexes,
+    } = batch;
+    let record_token_balances = transaction_status_sender.is_some();
 
-    if let Some(transaction_status_sender) = transaction_status_sender {
-        let transactions = batch.sanitized_transactions().to_vec();
-        let post_token_balances = if record_token_balances {
-            collect_token_balances(bank, batch, &mut mint_decimals)
-        } else {
-            vec![]
-        };
+    let mut mint_decimals: HashMap<Pubkey, u8> = HashMap::new();
 
-        let token_balances =
-            TransactionTokenBalancesSet::new(pre_token_balances, post_token_balances);
-
-        transaction_status_sender.send_transaction_status_batch(
-            bank.clone(),
-            transactions,
-            execution_results,
-            balances,
-            token_balances,
-            rent_debits,
-            transaction_indexes.to_vec(),
-        );
-    }
+    let pre_token_balances = if record_token_balances {
+        collect_token_balances(bank, batch, &mut mint_decimals)
+    } else {
+        vec![]
+    };
 
-    prioritization_fee_cache.update(bank, executed_transactions.into_iter());
+    batch.bank().load_execute_and_commit_transactions2(
+        batch,
+        MAX_PROCESSING_AGE,
+        transaction_status_sender.is_some(),
+        transaction_status_sender.is_some(),
+        transaction_status_sender.is_some(),
+        transaction_status_sender.is_some(),
+        timings,
+        log_messages_bytes_limit,
+    );
 
-    let first_err = get_first_error(batch, fee_collection_results);
-    first_err.map(|(result, _)| result).unwrap_or(Ok(()))
+    Ok(())
 }
 
 #[derive(Default)]
@@ -3914,54 +3907,7 @@ pub mod tests {
 
     #[test]
     fn test_get_first_error() {
-        let GenesisConfigInfo {
-            genesis_config,
-            mint_keypair,
-            ..
-        } = create_genesis_config(1_000_000_000);
-        let bank = Bank::new_with_bank_forks_for_tests(&genesis_config).0;
-
-        let present_account_key = Keypair::new();
-        let present_account = AccountSharedData::new(1, 10, &Pubkey::default());
-        bank.store_account(&present_account_key.pubkey(), &present_account);
-
-        let keypair = Keypair::new();
-
-        // Create array of two transactions which throw different errors
-        let account_not_found_tx = system_transaction::transfer(
-            &keypair,
-            &solana_sdk::pubkey::new_rand(),
-            42,
-            bank.last_blockhash(),
-        );
-        let account_not_found_sig = account_not_found_tx.signatures[0];
-        let invalid_blockhash_tx = system_transaction::transfer(
-            &mint_keypair,
-            &solana_sdk::pubkey::new_rand(),
-            42,
-            Hash::default(),
-        );
-        let txs = vec![account_not_found_tx, invalid_blockhash_tx];
-        let batch = bank.prepare_batch_for_tests(txs);
-        let (
-            TransactionResults {
-                fee_collection_results,
-                ..
-            },
-            _balances,
-        ) = batch.bank().load_execute_and_commit_transactions(
-            &batch,
-            MAX_PROCESSING_AGE,
-            false,
-            false,
-            false,
-            false,
-            &mut ExecuteTimings::default(),
-            None,
-        );
-        let (err, signature) = get_first_error(&batch, fee_collection_results).unwrap();
-        assert_eq!(err.unwrap_err(), TransactionError::AccountNotFound);
-        assert_eq!(signature, account_not_found_sig);
+        todo!();
     }
 
     #[test]