Simulate leader blocks wip

Cargo.toml

@@ -271,9 +271,6 @@ index_list = "0.2.13"
 indexmap = "2.5.0"
 indicatif = "0.17.8"
 itertools = "0.12.1"
-jemallocator = { package = "tikv-jemallocator", version = "0.4.1", features = [
-    "unprefixed_malloc_on_supported_platforms",
-] }
 js-sys = "0.3.70"
 json5 = "0.4.1"
 jsonrpc-core = "18.0.0"
@@ -297,9 +294,11 @@ lz4 = "1.26.0"
 memmap2 = "0.5.10"
 memoffset = "0.9"
 merlin = "3"
+mimalloc = "0.1.43"
 min-max-heap = "1.3.0"
 mockall = "0.11.4"
 modular-bitfield = "0.11.2"
+more-asserts = "0.3.1"
 nix = "0.29.0"
 num-bigint = "0.4.6"
 num-derive = "0.4"

banking-bench/Cargo.toml

@@ -12,6 +12,7 @@ edition = { workspace = true }
 clap = { version = "3.1.8", features = ["derive", "cargo"] }
 crossbeam-channel = { workspace = true }
 log = { workspace = true }
+mimalloc = "0.1.42"
 rand = { workspace = true }
 rayon = { workspace = true }
 solana-client = { workspace = true }
@@ -26,6 +27,7 @@ solana-runtime = { workspace = true, features = ["dev-context-only-utils"] }
 solana-sdk = { workspace = true }
 solana-streamer = { workspace = true }
 solana-tpu-client = { workspace = true }
+solana-unified-scheduler-pool = { workspace = true }
 solana-version = { workspace = true }
 
 [features]

banking-bench/src/main.rs

@@ -29,19 +29,25 @@ use {
         hash::Hash,
         message::Message,
         pubkey::{self, Pubkey},
+        scheduling::SchedulingMode,
         signature::{Keypair, Signature, Signer},
         system_instruction, system_transaction,
         timing::timestamp,
         transaction::Transaction,
     },
     solana_streamer::socket::SocketAddrSpace,
     solana_tpu_client::tpu_client::DEFAULT_TPU_CONNECTION_POOL_SIZE,
+    solana_unified_scheduler_pool::DefaultSchedulerPool,
     std::{
         sync::{atomic::Ordering, Arc, RwLock},
         thread::sleep,
         time::{Duration, Instant},
     },
 };
+use solana_unified_scheduler_pool::SupportedSchedulingMode;
+
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 
 // transfer transaction cost = 1 * SIGNATURE_COST +
 //                             2 * WRITE_LOCK_UNITS +
@@ -58,10 +64,12 @@ fn check_txs(
     let now = Instant::now();
     let mut no_bank = false;
     loop {
-        if let Ok((_bank, (entry, _tick_height))) = receiver.recv_timeout(Duration::from_millis(10))
-        {
+        if let Ok((_bank, (entry, _tick_height))) = receiver.try_recv() {
             total += entry.transactions.len();
+        } else {
+            sleep(Duration::from_millis(10));
         }
+
         if total >= ref_tx_count {
             break;
         }
@@ -347,7 +355,7 @@ fn main() {
     let (replay_vote_sender, _replay_vote_receiver) = unbounded();
     let bank0 = Bank::new_for_benches(&genesis_config);
     let bank_forks = BankForks::new_rw_arc(bank0);
-    let mut bank = bank_forks.read().unwrap().working_bank();
+    let mut bank = bank_forks.read().unwrap().working_bank_with_scheduler().clone_with_scheduler();
 
     // set cost tracker limits to MAX so it will not filter out TXs
     bank.write_cost_tracker()
@@ -441,8 +449,16 @@ fn main() {
         )))
         .unwrap();
     let (non_vote_sender, non_vote_receiver) = banking_tracer.create_channel_non_vote();
-    let (tpu_vote_sender, tpu_vote_receiver) = banking_tracer.create_channel_tpu_vote();
-    let (gossip_vote_sender, gossip_vote_receiver) = banking_tracer.create_channel_gossip_vote();
+    let (tpu_vote_sender, tpu_vote_receiver) = if let BlockProductionMethod::UnifiedScheduler = block_production_method {
+        banking_tracer.create_unified_channel_tpu_vote(&non_vote_sender, &non_vote_receiver)
+    } else {
+        banking_tracer.create_channel_tpu_vote()
+    };
+    let (gossip_vote_sender, gossip_vote_receiver) = if let BlockProductionMethod::UnifiedScheduler = block_production_method {
+        banking_tracer.create_unified_channel_gossip_vote(&non_vote_sender, &non_vote_receiver)
+    } else {
+        banking_tracer.create_channel_gossip_vote()
+    };
     let cluster_info = {
         let keypair = Arc::new(Keypair::new());
         let node = Node::new_localhost_with_pubkey(&keypair.pubkey());
@@ -460,8 +476,29 @@ fn main() {
             DEFAULT_TPU_CONNECTION_POOL_SIZE,
         ),
     };
+    let prioritization_fee_cache = Arc::new(PrioritizationFeeCache::new(0u64));
+    let collector = solana_sdk::pubkey::new_rand();
+    let scheduler_pool = if matches!(block_production_method, BlockProductionMethod::UnifiedScheduler) {
+        let scheduler_pool = DefaultSchedulerPool::new(
+            SupportedSchedulingMode::Either(SchedulingMode::BlockProduction),
+            Some((num_banking_threads - 2) as usize),
+            None,
+            None,
+            Some(replay_vote_sender.clone()),
+            prioritization_fee_cache.clone(),
+            Some(poh_recorder.read().unwrap().new_recorder()),
+        );
+        bank_forks
+            .write()
+            .unwrap()
+            .install_scheduler_pool(scheduler_pool.clone());
+        Some(scheduler_pool)
+    } else {
+        None
+    };
+
     let banking_stage = BankingStage::new_num_threads(
-        block_production_method,
+        block_production_method.clone(),
         &cluster_info,
         &poh_recorder,
         non_vote_receiver,
@@ -473,10 +510,29 @@ fn main() {
         None,
         Arc::new(connection_cache),
         bank_forks.clone(),
-        &Arc::new(PrioritizationFeeCache::new(0u64)),
+        &prioritization_fee_cache,
         false,
+        scheduler_pool,
     );
 
+    if matches!(block_production_method, BlockProductionMethod::UnifiedScheduler) {
+        sleep(Duration::from_millis(111));
+        bank_forks
+            .write()
+            .unwrap()
+            .reinstall_schedulers(SchedulingMode::BlockProduction);
+        bank = bank_forks
+            .read()
+            .unwrap()
+            .working_bank_with_scheduler()
+            .clone_with_scheduler()
+    }
+    // todo: proper assert!
+    let _ = poh_recorder
+        .write()
+        .unwrap()
+        .reset(bank.clone(), Some((bank.slot(), bank.slot() + 1)));
+
     // This is so that the signal_receiver does not go out of scope after the closure.
     // If it is dropped before poh_service, then poh_service will error when
     // calling send() on the channel.
@@ -485,7 +541,6 @@ fn main() {
     let mut tx_total_us = 0;
     let base_tx_count = bank.transaction_count();
     let mut txs_processed = 0;
-    let collector = solana_sdk::pubkey::new_rand();
     let mut total_sent = 0;
     for current_iteration_index in 0..iterations {
         trace!("RUNNING ITERATION {}", current_iteration_index);
@@ -537,33 +592,37 @@ fn main() {
             tx_total_us += now.elapsed().as_micros() as u64;
 
             let mut poh_time = Measure::start("poh_time");
-            poh_recorder
+            // todo: proper assert!
+            let _ = poh_recorder
                 .write()
                 .unwrap()
                 .reset(bank.clone(), Some((bank.slot(), bank.slot() + 1)));
             poh_time.stop();
 
             let mut new_bank_time = Measure::start("new_bank");
             let new_slot = bank.slot() + 1;
-            let new_bank = Bank::new_from_parent(bank, &collector, new_slot);
+            let new_bank = Bank::new_from_parent(bank.clone(), &collector, new_slot);
+            if let Some((result, _timings)) = bank.wait_for_completed_scheduler() {
+               result.unwrap();
+            }
             new_bank_time.stop();
 
             let mut insert_time = Measure::start("insert_time");
-            bank_forks.write().unwrap().insert(new_bank);
-            bank = bank_forks.read().unwrap().working_bank();
+            let mut poh_recorder_write = poh_recorder.write().unwrap();
+            bank_forks
+                .write()
+                .unwrap()
+                .insert_with_scheduling_mode(SchedulingMode::BlockProduction, new_bank);
+            bank = bank_forks.read().unwrap().working_bank_with_scheduler().clone_with_scheduler();
             insert_time.stop();
 
             // set cost tracker limits to MAX so it will not filter out TXs
             bank.write_cost_tracker()
                 .unwrap()
                 .set_limits(u64::MAX, u64::MAX, u64::MAX);
 
-            assert!(poh_recorder.read().unwrap().bank().is_none());
-            poh_recorder
-                .write()
-                .unwrap()
-                .set_bank_for_test(bank.clone());
-            assert!(poh_recorder.read().unwrap().bank().is_some());
+            assert!(poh_recorder_write.bank().is_none());
+            poh_recorder_write.set_bank_for_test(bank.clone());
             debug!(
                 "new_bank_time: {}us insert_time: {}us poh_time: {}us",
                 new_bank_time.as_us(),

bench-tps/Cargo.toml

@@ -14,6 +14,7 @@ clap = { workspace = true }
 crossbeam-channel = { workspace = true }
 csv = { workspace = true }
 log = { workspace = true }
+mimalloc = "0.1.42"
 rand = { workspace = true }
 rayon = { workspace = true }
 serde = { workspace = true }

bench-tps/src/main.rs

@@ -31,6 +31,9 @@ use {
     },
 };
 
+#[global_allocator]
+static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
+
 /// Number of signatures for all transactions in ~1 week at ~100K TPS
 pub const NUM_SIGNATURES_FOR_TXS: u64 = 100_000 * 60 * 60 * 24 * 7;
 

cli-output/Cargo.toml

@@ -17,6 +17,7 @@ clap = "2.33.0"
 console = { workspace = true }
 humantime = { workspace = true }
 indicatif = { workspace = true }
+log = { workspace = true }
 pretty-hex = { workspace = true }
 semver = { workspace = true }
 serde = { workspace = true }

cli/src/cluster_query.rs

@@ -1526,6 +1526,7 @@ pub fn process_ping(
             format!("[{}.{:06}] ", micros / 1_000_000, micros % 1_000_000)
         };
 
+        log::warn!("before send_transaction");
         match tps_client.send_transaction(tx) {
             Ok(signature) => {
                 let transaction_sent = Instant::now();
@@ -1537,6 +1538,7 @@ pub fn process_ping(
                             Ok(()) => {
                                 let elapsed_time_millis = elapsed_time.as_millis() as u64;
                                 confirmation_time.push_back(elapsed_time_millis);
+                                log::warn!("ping succeeded: {elapsed_time_millis}ms!");
                                 let cli_ping_data = CliPingData {
                                     success: true,
                                     signature: Some(signature.to_string()),