blockstore_processor now accepts an Arc<Rwlock<BankForks>>
This commit is contained in:
parent
0e2e0c8b7d
commit
c6f3da4879
|
@ -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<PohTimingSender>,
|
||||
) -> (
|
||||
GenesisConfig,
|
||||
BankForks,
|
||||
Arc<RwLock<BankForks>>,
|
||||
Arc<Blockstore>,
|
||||
Receiver<bool>,
|
||||
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<BankForks>,
|
||||
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<BankForks>,
|
||||
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,
|
||||
));
|
||||
|
|
|
@ -729,7 +729,7 @@ fn load_bank_forks(
|
|||
blockstore: &Blockstore,
|
||||
process_options: ProcessOptions,
|
||||
snapshot_archive_path: Option<PathBuf>,
|
||||
) -> Result<(BankForks, Option<StartingSnapshotHashes>), BlockstoreProcessorError> {
|
||||
) -> Result<(Arc<RwLock<BankForks>>, Option<StartingSnapshotHashes>), 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);
|
||||
|
|
|
@ -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<RwLock<BankForks>>,
|
||||
LeaderScheduleCache,
|
||||
Option<StartingSnapshotHashes>,
|
||||
),
|
||||
|
@ -52,7 +57,7 @@ pub fn load(
|
|||
pending_accounts_package: PendingAccountsPackage,
|
||||
accounts_update_notifier: Option<AccountsUpdateNotifier>,
|
||||
) -> 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<AccountsUpdateNotifier>,
|
||||
) -> (
|
||||
BankForks,
|
||||
Arc<RwLock<BankForks>>,
|
||||
LeaderScheduleCache,
|
||||
Option<StartingSnapshotHashes>,
|
||||
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<AccountsUpdateNotifier>,
|
||||
) -> (BankForks, Option<StartingSnapshotHashes>) {
|
||||
) -> (Arc<RwLock<BankForks>>, Option<StartingSnapshotHashes>) {
|
||||
// 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),
|
||||
)
|
||||
}
|
||||
|
|
|
@ -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<RwLock<BankForks>>, 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<AccountsUpdateNotifier>,
|
||||
) -> BankForks {
|
||||
) -> Arc<RwLock<BankForks>> {
|
||||
// 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<BankForks>,
|
||||
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::<Vec<_>>();
|
||||
bank_slots.sort_unstable();
|
||||
{
|
||||
let bank_forks = bank_forks.read().unwrap();
|
||||
let mut bank_slots = bank_forks.banks().keys().collect::<Vec<_>>();
|
||||
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<BankForks>,
|
||||
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);
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue