From c6f3da4879f39025086b074f19e8247671ad4647 Mon Sep 17 00:00:00 2001 From: Michael Vines Date: Fri, 4 Mar 2022 10:52:22 +0100 Subject: [PATCH] blockstore_processor now accepts an Arc> --- core/src/validator.rs | 74 +++++++++++-------- ledger-tool/src/main.rs | 27 +++++-- ledger/src/bank_forks_utils.rs | 49 +++++++----- ledger/src/blockstore_processor.rs | 115 ++++++++++++++++++----------- 4 files changed, 161 insertions(+), 104 deletions(-) diff --git a/core/src/validator.rs b/core/src/validator.rs index 0ee27fc7c4..c3cadbe8f8 100644 --- a/core/src/validator.rs +++ b/core/src/validator.rs @@ -491,7 +491,7 @@ impl Validator { let ( genesis_config, - mut bank_forks, + bank_forks, blockstore, ledger_signal_receiver, completed_slots_receiver, @@ -522,7 +522,7 @@ impl Validator { let pending_accounts_package = PendingAccountsPackage::default(); let last_full_snapshot_slot = process_blockstore( &blockstore, - &mut bank_forks, + &bank_forks, &leader_schedule_cache, &blockstore_process_options, transaction_status_sender.as_ref(), @@ -535,7 +535,8 @@ impl Validator { let last_full_snapshot_slot = last_full_snapshot_slot.or_else(|| starting_snapshot_hashes.map(|x| x.full.hash.0)); - maybe_warp_slot(config, ledger_path, &mut bank_forks, &leader_schedule_cache); + maybe_warp_slot(config, ledger_path, &bank_forks, &leader_schedule_cache); + let tower = { let restored_tower = Tower::restore(config.tower_storage.as_ref(), &id); if let Ok(tower) = &restored_tower { @@ -545,7 +546,13 @@ impl Validator { }); } - post_process_restored_tower(restored_tower, &id, vote_account, config, &bank_forks) + post_process_restored_tower( + restored_tower, + &id, + vote_account, + config, + &bank_forks.read().unwrap(), + ) }; info!("Tower state: {:?}", tower); @@ -559,7 +566,6 @@ impl Validator { } let leader_schedule_cache = Arc::new(leader_schedule_cache); - let bank_forks = Arc::new(RwLock::new(bank_forks)); let sample_performance_service = if config.rpc_addrs.is_some() && config.rpc_config.enable_rpc_transaction_history { @@ -1321,7 +1327,7 @@ fn load_blockstore( poh_timing_point_sender: Option, ) -> ( GenesisConfig, - BankForks, + Arc>, Arc, Receiver, CompletedSlotsReceiver, @@ -1409,26 +1415,24 @@ fn load_blockstore( TransactionHistoryServices::default() }; - let ( - mut bank_forks, - mut leader_schedule_cache, - starting_snapshot_hashes, - pruned_banks_receiver, - ) = bank_forks_utils::load_bank_forks( - &genesis_config, - &blockstore, - config.account_paths.clone(), - config.account_shrink_paths.clone(), - config.snapshot_config.as_ref(), - &process_options, - transaction_history_services - .cache_block_meta_sender - .as_ref(), - accounts_update_notifier, - ); + let (bank_forks, mut leader_schedule_cache, starting_snapshot_hashes, pruned_banks_receiver) = + bank_forks_utils::load_bank_forks( + &genesis_config, + &blockstore, + config.account_paths.clone(), + config.account_shrink_paths.clone(), + config.snapshot_config.as_ref(), + &process_options, + transaction_history_services + .cache_block_meta_sender + .as_ref(), + accounts_update_notifier, + ); { let hard_forks: Vec<_> = bank_forks + .read() + .unwrap() .working_bank() .hard_forks() .read() @@ -1442,12 +1446,15 @@ fn load_blockstore( } leader_schedule_cache.set_fixed_leader_schedule(config.fixed_leader_schedule.clone()); - bank_forks.set_snapshot_config(config.snapshot_config.clone()); - bank_forks.set_accounts_hash_interval_slots(config.accounts_hash_interval_slots); - if let Some(ref shrink_paths) = config.account_shrink_paths { - bank_forks - .working_bank() - .set_shrink_paths(shrink_paths.clone()); + { + let mut bank_forks = bank_forks.write().unwrap(); + bank_forks.set_snapshot_config(config.snapshot_config.clone()); + bank_forks.set_accounts_hash_interval_slots(config.accounts_hash_interval_slots); + if let Some(ref shrink_paths) = config.account_shrink_paths { + bank_forks + .working_bank() + .set_shrink_paths(shrink_paths.clone()); + } } ( @@ -1468,7 +1475,7 @@ fn load_blockstore( #[allow(clippy::too_many_arguments)] fn process_blockstore( blockstore: &Blockstore, - bank_forks: &mut BankForks, + bank_forks: &RwLock, leader_schedule_cache: &LeaderScheduleCache, process_options: &blockstore_processor::ProcessOptions, transaction_status_sender: Option<&TransactionStatusSender>, @@ -1502,7 +1509,7 @@ fn process_blockstore( fn maybe_warp_slot( config: &ValidatorConfig, ledger_path: &Path, - bank_forks: &mut BankForks, + bank_forks: &RwLock, leader_schedule_cache: &LeaderScheduleCache, ) { if let Some(warp_slot) = config.warp_slot { @@ -1511,6 +1518,8 @@ fn maybe_warp_slot( abort(); }); + let mut bank_forks = bank_forks.write().unwrap(); + let working_bank = bank_forks.working_bank(); if warp_slot <= working_bank.slot() { @@ -1523,8 +1532,9 @@ fn maybe_warp_slot( } info!("warping to slot {}", warp_slot); + let root_bank = bank_forks.root_bank(); bank_forks.insert(Bank::warp_from_parent( - &bank_forks.root_bank(), + &root_bank, &Pubkey::default(), warp_slot, )); diff --git a/ledger-tool/src/main.rs b/ledger-tool/src/main.rs index 943078ea85..dcbe7dcee7 100644 --- a/ledger-tool/src/main.rs +++ b/ledger-tool/src/main.rs @@ -729,7 +729,7 @@ fn load_bank_forks( blockstore: &Blockstore, process_options: ProcessOptions, snapshot_archive_path: Option, -) -> Result<(BankForks, Option), BlockstoreProcessorError> { +) -> Result<(Arc>, Option), BlockstoreProcessorError> { let bank_snapshots_dir = blockstore .ledger_path() .join(if blockstore.is_primary_access() { @@ -1812,7 +1812,15 @@ fn main() { "{}", compute_shred_version( &genesis_config.hash(), - Some(&bank_forks.working_bank().hard_forks().read().unwrap()) + Some( + &bank_forks + .read() + .unwrap() + .working_bank() + .hard_forks() + .read() + .unwrap() + ) ) ); } @@ -1888,7 +1896,7 @@ fn main() { snapshot_archive_path, ) { Ok((bank_forks, ..)) => { - println!("{}", &bank_forks.working_bank().hash()); + println!("{}", &bank_forks.read().unwrap().working_bank().hash()); } Err(err) => { eprintln!("Failed to load ledger: {:?}", err); @@ -2143,7 +2151,7 @@ fn main() { exit(1); }); if print_accounts_stats { - let working_bank = bank_forks.working_bank(); + let working_bank = bank_forks.read().unwrap().working_bank(); working_bank.print_accounts_stats(); } exit_signal.store(true, Ordering::Relaxed); @@ -2176,8 +2184,10 @@ fn main() { snapshot_archive_path, ) { Ok((bank_forks, ..)) => { - let dot = - graph_forks(&bank_forks, arg_matches.is_present("include_all_votes")); + let dot = graph_forks( + &bank_forks.read().unwrap(), + arg_matches.is_present("include_all_votes"), + ); let extension = Path::new(&output_file).extension(); let result = if extension == Some(OsStr::new("pdf")) { @@ -2295,6 +2305,8 @@ fn main() { ) { Ok((bank_forks, starting_snapshot_hashes)) => { let mut bank = bank_forks + .read() + .unwrap() .get(snapshot_slot) .unwrap_or_else(|| { eprintln!("Error: Slot {} is not available", snapshot_slot); @@ -2610,7 +2622,7 @@ fn main() { exit(1); }); - let bank = bank_forks.working_bank(); + let bank = bank_forks.read().unwrap().working_bank(); let mut measure = Measure::start("getting accounts"); let accounts: BTreeMap<_, _> = bank .get_all_accounts_with_modified_slots() @@ -2671,6 +2683,7 @@ fn main() { snapshot_archive_path, ) { Ok((bank_forks, ..)) => { + let bank_forks = bank_forks.read().unwrap(); let slot = bank_forks.working_bank().slot(); let bank = bank_forks.get(slot).unwrap_or_else(|| { eprintln!("Error: Slot {} is not available", slot); diff --git a/ledger/src/bank_forks_utils.rs b/ledger/src/bank_forks_utils.rs index e88d04cbf0..802c7ed055 100644 --- a/ledger/src/bank_forks_utils.rs +++ b/ledger/src/bank_forks_utils.rs @@ -20,12 +20,17 @@ use { snapshot_utils, }, solana_sdk::genesis_config::GenesisConfig, - std::{fs, path::PathBuf, process, result}, + std::{ + fs, + path::PathBuf, + process, result, + sync::{Arc, RwLock}, + }, }; pub type LoadResult = result::Result< ( - BankForks, + Arc>, LeaderScheduleCache, Option, ), @@ -52,7 +57,7 @@ pub fn load( pending_accounts_package: PendingAccountsPackage, accounts_update_notifier: Option, ) -> LoadResult { - let (mut bank_forks, leader_schedule_cache, starting_snapshot_hashes, pruned_banks_receiver) = + let (bank_forks, leader_schedule_cache, starting_snapshot_hashes, pruned_banks_receiver) = load_bank_forks( genesis_config, blockstore, @@ -66,7 +71,7 @@ pub fn load( blockstore_processor::process_blockstore_from_root( blockstore, - &mut bank_forks, + &bank_forks, &leader_schedule_cache, &process_options, transaction_status_sender, @@ -89,7 +94,7 @@ pub fn load_bank_forks( cache_block_meta_sender: Option<&CacheBlockMetaSender>, accounts_update_notifier: Option, ) -> ( - BankForks, + Arc>, LeaderScheduleCache, Option, DroppedSlotsReceiver, @@ -160,23 +165,27 @@ pub fn load_bank_forks( // There should only be one bank, the root bank in BankForks. Thus all banks added to // BankForks from now on will be descended from the root bank and thus will inherit // the bank drop callback. - assert_eq!(bank_forks.banks().len(), 1); + assert_eq!(bank_forks.read().unwrap().banks().len(), 1); let (pruned_banks_sender, pruned_banks_receiver) = bounded(MAX_DROP_BANK_SIGNAL_QUEUE_SIZE); - let root_bank = bank_forks.root_bank(); - let callback = root_bank - .rc - .accounts - .accounts_db - .create_drop_bank_callback(pruned_banks_sender); - root_bank.set_callback(Some(Box::new(callback))); - let mut leader_schedule_cache = LeaderScheduleCache::new_from_bank(&root_bank); - if process_options.full_leader_cache { - leader_schedule_cache.set_max_schedules(std::usize::MAX); - } + let leader_schedule_cache = { + let root_bank = bank_forks.read().unwrap().root_bank(); + let callback = root_bank + .rc + .accounts + .accounts_db + .create_drop_bank_callback(pruned_banks_sender); + root_bank.set_callback(Some(Box::new(callback))); + + let mut leader_schedule_cache = LeaderScheduleCache::new_from_bank(&root_bank); + if process_options.full_leader_cache { + leader_schedule_cache.set_max_schedules(std::usize::MAX); + } + leader_schedule_cache + }; if let Some(ref new_hard_forks) = process_options.new_hard_forks { - let root_bank = bank_forks.root_bank(); + let root_bank = bank_forks.read().unwrap().root_bank(); let hard_forks = root_bank.hard_forks(); for hard_fork_slot in new_hard_forks.iter() { @@ -207,7 +216,7 @@ fn bank_forks_from_snapshot( snapshot_config: &SnapshotConfig, process_options: &ProcessOptions, accounts_update_notifier: Option, -) -> (BankForks, Option) { +) -> (Arc>, Option) { // Fail hard here if snapshot fails to load, don't silently continue if account_paths.is_empty() { error!("Account paths not present when booting from snapshot"); @@ -264,7 +273,7 @@ fn bank_forks_from_snapshot( }; ( - BankForks::new(deserialized_bank), + Arc::new(RwLock::new(BankForks::new(deserialized_bank))), Some(starting_snapshot_hashes), ) } diff --git a/ledger/src/blockstore_processor.rs b/ledger/src/blockstore_processor.rs index aa25c5e5b2..39f10f3084 100644 --- a/ledger/src/blockstore_processor.rs +++ b/ledger/src/blockstore_processor.rs @@ -567,8 +567,8 @@ pub fn test_process_blockstore( genesis_config: &GenesisConfig, blockstore: &Blockstore, opts: ProcessOptions, -) -> (BankForks, LeaderScheduleCache) { - let (mut bank_forks, leader_schedule_cache, .., pruned_banks_receiver) = +) -> (Arc>, LeaderScheduleCache) { + let (bank_forks, leader_schedule_cache, .., pruned_banks_receiver) = crate::bank_forks_utils::load_bank_forks( genesis_config, blockstore, @@ -581,7 +581,7 @@ pub fn test_process_blockstore( ); process_blockstore_from_root( blockstore, - &mut bank_forks, + &bank_forks, &leader_schedule_cache, &opts, None, @@ -601,7 +601,7 @@ pub(crate) fn process_blockstore_for_bank_0( opts: &ProcessOptions, cache_block_meta_sender: Option<&CacheBlockMetaSender>, accounts_update_notifier: Option, -) -> BankForks { +) -> Arc> { // Setup bank for slot 0 let mut bank0 = Bank::new_with_paths( genesis_config, @@ -616,11 +616,11 @@ pub(crate) fn process_blockstore_for_bank_0( accounts_update_notifier, ); bank0.set_compute_budget(opts.runtime_config.compute_budget); - let bank_forks = BankForks::new(bank0); + let bank_forks = Arc::new(RwLock::new(BankForks::new(bank0))); info!("processing ledger for slot 0..."); process_bank_0( - &bank_forks.root_bank(), + &bank_forks.read().unwrap().root_bank(), blockstore, opts, &VerifyRecyclers::default(), @@ -633,7 +633,7 @@ pub(crate) fn process_blockstore_for_bank_0( #[allow(clippy::too_many_arguments)] pub fn process_blockstore_from_root( blockstore: &Blockstore, - bank_forks: &mut BankForks, + bank_forks: &RwLock, leader_schedule_cache: &LeaderScheduleCache, opts: &ProcessOptions, transaction_status_sender: Option<&TransactionStatusSender>, @@ -652,8 +652,8 @@ pub fn process_blockstore_from_root( } // Starting slot must be a root, and thus has no parents - assert_eq!(bank_forks.banks().len(), 1); - let bank = bank_forks.root_bank(); + assert_eq!(bank_forks.read().unwrap().banks().len(), 1); + let bank = bank_forks.read().unwrap().root_bank(); assert!(bank.parent().is_none()); let start_slot = bank.slot(); @@ -716,11 +716,15 @@ pub fn process_blockstore_from_root( // In that case, we're most likely restored from the last good snapshot and replayed up to this root. // So again check here for the bad capitalization to avoid to continue until the next snapshot creation. if !bank_forks + .read() + .unwrap() .root_bank() .calculate_and_verify_capitalization(debug_verify) { return Err( - BlockstoreProcessorError::RootBankWithMismatchedCapitalization(bank_forks.root()), + BlockstoreProcessorError::RootBankWithMismatchedCapitalization( + bank_forks.read().unwrap().root(), + ), ); } time_cap.stop(); @@ -728,26 +732,33 @@ pub fn process_blockstore_from_root( datapoint_info!( "process_blockstore_from_root", ("total_time_us", processing_time.as_micros(), i64), - ("frozen_banks", bank_forks.frozen_banks().len(), i64), - ("slot", bank_forks.root(), i64), - ("forks", bank_forks.banks().len(), i64), + ( + "frozen_banks", + bank_forks.read().unwrap().frozen_banks().len(), + i64 + ), + ("slot", bank_forks.read().unwrap().root(), i64), + ("forks", bank_forks.read().unwrap().banks().len(), i64), ("calculate_capitalization_us", time_cap.as_us(), i64), ); info!("ledger processing timing: {:?}", timing); - let mut bank_slots = bank_forks.banks().keys().collect::>(); - bank_slots.sort_unstable(); + { + let bank_forks = bank_forks.read().unwrap(); + let mut bank_slots = bank_forks.banks().keys().collect::>(); + bank_slots.sort_unstable(); - info!( - "ledger processed in {}. root slot is {}, {} bank{}: {}", - HumanTime::from(chrono::Duration::from_std(processing_time).unwrap()) - .to_text_en(Accuracy::Precise, Tense::Present), - bank_forks.root(), - bank_slots.len(), - if bank_slots.len() > 1 { "s" } else { "" }, - bank_slots.iter().map(|slot| slot.to_string()).join(", "), - ); - assert!(bank_forks.active_banks().is_empty()); + info!( + "ledger processed in {}. root slot is {}, {} bank{}: {}", + HumanTime::from(chrono::Duration::from_std(processing_time).unwrap()) + .to_text_en(Accuracy::Precise, Tense::Present), + bank_forks.root(), + bank_slots.len(), + if bank_slots.len() > 1 { "s" } else { "" }, + bank_slots.iter().map(|slot| slot.to_string()).join(", "), + ); + assert!(bank_forks.active_banks().is_empty()); + } Ok(last_full_snapshot_slot) } @@ -1139,7 +1150,7 @@ fn process_next_slots( // given `meta` and return a vector of frozen bank forks #[allow(clippy::too_many_arguments)] fn load_frozen_forks( - bank_forks: &mut BankForks, + bank_forks: &RwLock, start_slot: Slot, start_slot_meta: &SlotMeta, blockstore: &Blockstore, @@ -1161,7 +1172,7 @@ fn load_frozen_forks( let mut slots_elapsed = 0; let mut txs = 0; let blockstore_max_root = blockstore.max_root(); - let mut root = bank_forks.root(); + let mut root = bank_forks.read().unwrap().root(); let max_root = std::cmp::max(root, blockstore_max_root); info!( @@ -1170,7 +1181,7 @@ fn load_frozen_forks( ); process_next_slots( - bank_forks.get(start_slot).unwrap(), + bank_forks.read().unwrap().get(start_slot).unwrap(), start_slot_meta, blockstore, leader_schedule_cache, @@ -1181,7 +1192,7 @@ fn load_frozen_forks( .runtime_config .dev_halt_at_slot .unwrap_or(std::u64::MAX); - if bank_forks.root() != dev_halt_at_slot { + if bank_forks.read().unwrap().root() != dev_halt_at_slot { while !pending_slots.is_empty() { timing.details.per_program_timings.clear(); let (meta, bank, last_entry_hash) = pending_slots.pop().unwrap(); @@ -1203,7 +1214,7 @@ fn load_frozen_forks( let mut progress = ConfirmationProgress::new(last_entry_hash); - let bank = bank_forks.insert(bank); + let bank = bank_forks.write().unwrap().insert(bank); if process_single_slot( blockstore, &bank, @@ -1217,7 +1228,7 @@ fn load_frozen_forks( ) .is_err() { - assert!(bank_forks.remove(bank.slot()).is_some()); + assert!(bank_forks.write().unwrap().remove(bank.slot()).is_some()); continue; } txs += progress.num_txs; @@ -1230,7 +1241,7 @@ fn load_frozen_forks( // If we've reached the last known root in blockstore, start looking // for newer cluster confirmed roots let new_root_bank = { - if bank_forks.root() >= max_root { + if bank_forks.read().unwrap().root() >= max_root { supermajority_root_from_vote_accounts( bank.slot(), bank.total_epoch_stake(), @@ -1281,7 +1292,7 @@ fn load_frozen_forks( root = new_root_bank.slot(); leader_schedule_cache.set_root(new_root_bank); - let _ = bank_forks.set_root( + let _ = bank_forks.write().unwrap().set_root( root, &solana_runtime::accounts_background_service::AbsRequestSender::default(), None, @@ -1621,7 +1632,6 @@ pub mod tests { vote_transaction, }, std::{collections::BTreeSet, sync::RwLock}, - tempfile::TempDir, trees::tr, }; @@ -1665,7 +1675,7 @@ pub mod tests { ..ProcessOptions::default() }, ); - assert_eq!(frozen_bank_slots(&bank_forks), vec![0]); + assert_eq!(frozen_bank_slots(&bank_forks.read().unwrap()), vec![0]); } #[test] @@ -1707,7 +1717,7 @@ pub mod tests { ..ProcessOptions::default() }, ); - assert_eq!(frozen_bank_slots(&bank_forks), vec![0]); + assert_eq!(frozen_bank_slots(&bank_forks.read().unwrap()), vec![0]); // Write slot 2 fully let _last_slot2_entry_hash = @@ -1723,9 +1733,9 @@ pub mod tests { ); // One valid fork, one bad fork. process_blockstore() should only return the valid fork - assert_eq!(frozen_bank_slots(&bank_forks), vec![0, 2]); - assert_eq!(bank_forks.working_bank().slot(), 2); - assert_eq!(bank_forks.root(), 0); + assert_eq!(frozen_bank_slots(&bank_forks.read().unwrap()), vec![0, 2]); + assert_eq!(bank_forks.read().unwrap().working_bank().slot(), 2); + assert_eq!(bank_forks.read().unwrap().root(), 0); } #[test] @@ -1775,7 +1785,7 @@ pub mod tests { ..ProcessOptions::default() }; let (bank_forks, ..) = test_process_blockstore(&genesis_config, &blockstore, opts); - assert_eq!(frozen_bank_slots(&bank_forks), vec![0]); + assert_eq!(frozen_bank_slots(&bank_forks.read().unwrap()), vec![0]); } #[test] @@ -1840,7 +1850,7 @@ pub mod tests { }; let (bank_forks, ..) = test_process_blockstore(&genesis_config, &blockstore, opts); - assert_eq!(frozen_bank_slots(&bank_forks), vec![0]); // slot 1 isn't "full", we stop at slot zero + assert_eq!(frozen_bank_slots(&bank_forks.read().unwrap()), vec![0]); // slot 1 isn't "full", we stop at slot zero /* Add a complete slot such that the store looks like: @@ -1860,7 +1870,7 @@ pub mod tests { let (bank_forks, ..) = test_process_blockstore(&genesis_config, &blockstore, opts); // slot 1 isn't "full", we stop at slot zero - assert_eq!(frozen_bank_slots(&bank_forks), vec![0, 3]); + assert_eq!(frozen_bank_slots(&bank_forks.read().unwrap()), vec![0, 3]); } #[test] @@ -1924,6 +1934,7 @@ pub mod tests { ..ProcessOptions::default() }; let (bank_forks, ..) = test_process_blockstore(&genesis_config, &blockstore, opts); + let bank_forks = bank_forks.read().unwrap(); // One fork, other one is ignored b/c not a descendant of the root assert_eq!(frozen_bank_slots(&bank_forks), vec![4]); @@ -2002,6 +2013,7 @@ pub mod tests { ..ProcessOptions::default() }; let (bank_forks, ..) = test_process_blockstore(&genesis_config, &blockstore, opts); + let bank_forks = bank_forks.read().unwrap(); assert_eq!(frozen_bank_slots(&bank_forks), vec![1, 2, 3, 4]); assert_eq!(bank_forks.working_bank().slot(), 4); @@ -2058,6 +2070,7 @@ pub mod tests { let (bank_forks, ..) = test_process_blockstore(&genesis_config, &blockstore, ProcessOptions::default()); + let bank_forks = bank_forks.read().unwrap(); assert_eq!(frozen_bank_slots(&bank_forks), vec![0, 1, 3]); assert_eq!(bank_forks.working_bank().slot(), 3); @@ -2102,6 +2115,7 @@ pub mod tests { let (bank_forks, ..) = test_process_blockstore(&genesis_config, &blockstore, ProcessOptions::default()); + let bank_forks = bank_forks.read().unwrap(); // Should see the parent of the dead child assert_eq!(frozen_bank_slots(&bank_forks), vec![0, 1, 2, 3]); @@ -2149,6 +2163,7 @@ pub mod tests { blockstore.set_dead_slot(2).unwrap(); let (bank_forks, ..) = test_process_blockstore(&genesis_config, &blockstore, ProcessOptions::default()); + let bank_forks = bank_forks.read().unwrap(); // Should see only the parent of the dead children assert_eq!(frozen_bank_slots(&bank_forks), vec![0]); @@ -2199,6 +2214,7 @@ pub mod tests { ..ProcessOptions::default() }; let (bank_forks, ..) = test_process_blockstore(&genesis_config, &blockstore, opts); + let bank_forks = bank_forks.read().unwrap(); // There is one fork, head is last_slot + 1 assert_eq!(frozen_bank_slots(&bank_forks), vec![last_slot + 1]); @@ -2342,6 +2358,7 @@ pub mod tests { ..ProcessOptions::default() }; let (bank_forks, ..) = test_process_blockstore(&genesis_config, &blockstore, opts); + let bank_forks = bank_forks.read().unwrap(); assert_eq!(frozen_bank_slots(&bank_forks), vec![0, 1]); assert_eq!(bank_forks.root(), 0); @@ -2371,6 +2388,7 @@ pub mod tests { ..ProcessOptions::default() }; let (bank_forks, ..) = test_process_blockstore(&genesis_config, &blockstore, opts); + let bank_forks = bank_forks.read().unwrap(); assert_eq!(frozen_bank_slots(&bank_forks), vec![0]); let bank = bank_forks[0].clone(); @@ -3124,6 +3142,7 @@ pub mod tests { ..ProcessOptions::default() }; let (bank_forks, ..) = test_process_blockstore(&genesis_config, &blockstore, opts); + let bank_forks = bank_forks.read().unwrap(); // Should be able to fetch slot 0 because we specified halting at slot 0, even // if there is a greater root at slot 1. @@ -3198,9 +3217,10 @@ pub mod tests { // Test process_blockstore_from_root() from slot 1 onwards let (_pruned_banks_sender, pruned_banks_receiver) = crossbeam_channel::unbounded(); + let bank_forks = RwLock::new(bank_forks); process_blockstore_from_root( &blockstore, - &mut bank_forks, + &bank_forks, &leader_schedule_cache, &opts, None, @@ -3211,6 +3231,8 @@ pub mod tests { ) .unwrap(); + let bank_forks = bank_forks.read().unwrap(); + assert_eq!(frozen_bank_slots(&bank_forks), vec![5, 6]); assert_eq!(bank_forks.working_bank().slot(), 6); assert_eq!(bank_forks.root(), 5); @@ -3298,7 +3320,7 @@ pub mod tests { None, ); - let bank_snapshots_tempdir = TempDir::new().unwrap(); + let bank_snapshots_tempdir = tempfile::TempDir::new().unwrap(); let snapshot_config = SnapshotConfig { full_snapshot_archive_interval_slots: FULL_SNAPSHOT_ARCHIVE_INTERVAL_SLOTS, bank_snapshots_dir: bank_snapshots_tempdir.path().to_path_buf(), @@ -3311,7 +3333,7 @@ pub mod tests { let (_pruned_banks_sender, pruned_banks_receiver) = crossbeam_channel::unbounded(); process_blockstore_from_root( &blockstore, - &mut bank_forks, + &RwLock::new(bank_forks), &leader_schedule_cache, &opts, None, @@ -3760,6 +3782,7 @@ pub mod tests { ..ProcessOptions::default() }; let (bank_forks, ..) = test_process_blockstore(&genesis_config, &blockstore, opts.clone()); + let bank_forks = bank_forks.read().unwrap(); // prepare to add votes let last_vote_bank_hash = bank_forks.get(last_main_fork_slot - 1).unwrap().hash(); @@ -3791,6 +3814,7 @@ pub mod tests { ); let (bank_forks, ..) = test_process_blockstore(&genesis_config, &blockstore, opts.clone()); + let bank_forks = bank_forks.read().unwrap(); assert_eq!(bank_forks.root(), expected_root_slot); assert_eq!( @@ -3845,6 +3869,7 @@ pub mod tests { ); let (bank_forks, ..) = test_process_blockstore(&genesis_config, &blockstore, opts); + let bank_forks = bank_forks.read().unwrap(); assert_eq!(bank_forks.root(), really_expected_root_slot); }