blockworks-foundation
/
solana
mirror of https://github.com/blockworks-foundation/solana.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Update all BankForks methods to return owned values (#24801)

This commit is contained in:
Justin Starry 2022-04-29 02:51:00 +08:00 committed by GitHub
parent b22a14ca68
commit 4e58b3870c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
19 changed files with 140 additions and 269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
client-test/tests/client.rs
View File

@ -125,7 +125,7 @@ fn test_account_subscription() {
let bank = Bank::new_for_tests(&genesis_config);
let blockhash = bank.last_blockhash();
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let bank0 = bank_forks.read().unwrap().get(0).unwrap().clone();
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
bank_forks.write().unwrap().insert(bank1);
let bob = Keypair::new();
@ -331,7 +331,7 @@ fn test_program_subscription() {
let bank = Bank::new_for_tests(&genesis_config);
let blockhash = bank.last_blockhash();
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let bank0 = bank_forks.read().unwrap().get(0).unwrap().clone();
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
bank_forks.write().unwrap().insert(bank1);
let bob = Keypair::new();
@ -418,7 +418,7 @@ fn test_root_subscription() {
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(10_000);
let bank = Bank::new_for_tests(&genesis_config);
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let bank0 = bank_forks.read().unwrap().get(0).unwrap().clone();
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
bank_forks.write().unwrap().insert(bank1);
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());

7
core/benches/consensus.rs
View File

@ -70,12 +70,7 @@ fn bench_generate_ancestors_descendants(bench: &mut Bencher) {
bench.iter(move || {
for _ in 0..num_banks {
let _ancestors = vote_simulator.bank_forks.read().unwrap().ancestors();
let _descendants = vote_simulator
.bank_forks
.read()
.unwrap()
.descendants()
.clone();
let _descendants = vote_simulator.bank_forks.read().unwrap().descendants();
}
});
}

2
core/src/ancestor_hashes_service.rs
View File

@ -1442,7 +1442,7 @@ mod test {
ReplayStage::dump_then_repair_correct_slots(
&mut duplicate_slots_to_repair,
&mut bank_forks.read().unwrap().ancestors(),
&mut bank_forks.read().unwrap().descendants().clone(),
&mut bank_forks.read().unwrap().descendants(),
&mut progress,
&bank_forks,
&requester_blockstore,

4
core/src/cluster_info_vote_listener.rs
View File

@ -1362,7 +1362,7 @@ mod tests {
let bank = Bank::new_for_tests(&genesis_config);
let exit = Arc::new(AtomicBool::new(false));
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let bank = bank_forks.read().unwrap().get(0).unwrap().clone();
let bank = bank_forks.read().unwrap().get(0).unwrap();
let vote_tracker = VoteTracker::default();
let optimistically_confirmed_bank =
OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks);
@ -1473,7 +1473,7 @@ mod tests {
let vote_tracker = VoteTracker::default();
let exit = Arc::new(AtomicBool::new(false));
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let bank = bank_forks.read().unwrap().get(0).unwrap().clone();
let bank = bank_forks.read().unwrap().get(0).unwrap();
let optimistically_confirmed_bank =
OptimisticallyConfirmedBank::locked_from_bank_forks_root(&bank_forks);
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());

9
core/src/cluster_slot_state_verifier.rs
View File

@ -1336,14 +1336,7 @@ mod test {
// Create simple fork 0 -> 1 -> 2 -> 3
let forks = tr(0) / (tr(1) / (tr(2) / tr(3)));
let (vote_simulator, blockstore) = setup_forks_from_tree(forks, 1, None);
let descendants = vote_simulator
.bank_forks
.read()
.unwrap()
.descendants()
.clone();
let descendants = vote_simulator.bank_forks.read().unwrap().descendants();
InitialState {
heaviest_subtree_fork_choice: vote_simulator.heaviest_subtree_fork_choice,
progress: vote_simulator.progress,

8
core/src/commitment_service.rs
View File

@ -516,7 +516,7 @@ mod tests {
// Create enough banks such that vote account will root slots 0 and 1
for x in 0..33 {
let previous_bank = bank_forks.get(x).unwrap();
let bank = Bank::new_from_parent(previous_bank, &Pubkey::default(), x + 1);
let bank = Bank::new_from_parent(&previous_bank, &Pubkey::default(), x + 1);
let vote = vote_transaction::new_vote_transaction(
vec![x],
previous_bank.hash(),
@ -541,7 +541,7 @@ mod tests {
// Add an additional bank/vote that will root slot 2
let bank33 = bank_forks.get(33).unwrap();
let bank34 = Bank::new_from_parent(bank33, &Pubkey::default(), 34);
let bank34 = Bank::new_from_parent(&bank33, &Pubkey::default(), 34);
let vote33 = vote_transaction::new_vote_transaction(
vec![33],
bank33.hash(),
@ -584,7 +584,7 @@ mod tests {
// Add a forked bank. Because the vote for bank 33 landed in the non-ancestor, the vote
// account's root (and thus the highest_confirmed_root) rolls back to slot 1
let bank33 = bank_forks.get(33).unwrap();
let bank35 = Bank::new_from_parent(bank33, &Pubkey::default(), 35);
let bank35 = Bank::new_from_parent(&bank33, &Pubkey::default(), 35);
bank_forks.insert(bank35);
let working_bank = bank_forks.working_bank();
@ -609,7 +609,7 @@ mod tests {
// continues normally
for x in 35..=37 {
let previous_bank = bank_forks.get(x).unwrap();
let bank = Bank::new_from_parent(previous_bank, &Pubkey::default(), x + 1);
let bank = Bank::new_from_parent(&previous_bank, &Pubkey::default(), x + 1);
let vote = vote_transaction::new_vote_transaction(
vec![x],
previous_bank.hash(),

76
core/src/consensus.rs
View File

@ -244,8 +244,7 @@ impl Tower {
.get_with_checked_hash((best_slot, best_hash))
.expect(
"The best overall slot must be one of `frozen_banks` which all exist in bank_forks",
)
.clone();
);
Self::new(node_pubkey, vote_account, root, &heaviest_bank)
}
@ -1522,13 +1521,7 @@ pub mod test {
// Init state
assert!(num_accounts > 1);
let mut vote_simulator = VoteSimulator::new(num_accounts);
let bank0 = vote_simulator
.bank_forks
.read()
.unwrap()
.get(0)
.unwrap()
.clone();
let bank0 = vote_simulator.bank_forks.read().unwrap().get(0).unwrap();
let total_stake = bank0.total_epoch_stake();
assert_eq!(
total_stake,
@ -1560,12 +1553,7 @@ pub mod test {
fn run_test_switch_threshold_duplicate_rollback(should_panic: bool) {
let (bank0, mut vote_simulator, total_stake) = setup_switch_test(2);
let ancestors = vote_simulator.bank_forks.read().unwrap().ancestors();
let descendants = vote_simulator
.bank_forks
.read()
.unwrap()
.descendants()
.clone();
let descendants = vote_simulator.bank_forks.read().unwrap().descendants();
let mut tower = Tower::default();
// Last vote is 47
@ -1666,12 +1654,7 @@ pub mod test {
fn test_switch_threshold() {
let (bank0, mut vote_simulator, total_stake) = setup_switch_test(2);
let ancestors = vote_simulator.bank_forks.read().unwrap().ancestors();
let mut descendants = vote_simulator
.bank_forks
.read()
.unwrap()
.descendants()
.clone();
let mut descendants = vote_simulator.bank_forks.read().unwrap().descendants();
let mut tower = Tower::default();
let other_vote_account = vote_simulator.vote_pubkeys[1];
@ -1819,12 +1802,7 @@ pub mod test {
tower.vote_state.root_slot = Some(43);
// Refresh ancestors and descendants for new root.
let ancestors = vote_simulator.bank_forks.read().unwrap().ancestors();
let descendants = vote_simulator
.bank_forks
.read()
.unwrap()
.descendants()
.clone();
let descendants = vote_simulator.bank_forks.read().unwrap().descendants();
assert_eq!(
tower.check_switch_threshold(
@ -1846,12 +1824,7 @@ pub mod test {
let num_validators = 2;
let (bank0, mut vote_simulator, total_stake) = setup_switch_test(2);
let ancestors = vote_simulator.bank_forks.read().unwrap().ancestors();
let descendants = vote_simulator
.bank_forks
.read()
.unwrap()
.descendants()
.clone();
let descendants = vote_simulator.bank_forks.read().unwrap().descendants();
let mut tower = Tower::default();
let other_vote_account = vote_simulator.vote_pubkeys[1];
@ -1927,12 +1900,7 @@ pub mod test {
// included in the switching proof
vote_simulator.set_root(44);
let ancestors = vote_simulator.bank_forks.read().unwrap().ancestors();
let descendants = vote_simulator
.bank_forks
.read()
.unwrap()
.descendants()
.clone();
let descendants = vote_simulator.bank_forks.read().unwrap().descendants();
assert_eq!(
tower.check_switch_threshold(
110,
@ -2574,13 +2542,7 @@ pub mod test {
// Init state
let mut vote_simulator = VoteSimulator::new(2);
let other_vote_account = vote_simulator.vote_pubkeys[1];
let bank0 = vote_simulator
.bank_forks
.read()
.unwrap()
.get(0)
.unwrap()
.clone();
let bank0 = vote_simulator.bank_forks.read().unwrap().get(0).unwrap();
let total_stake = bank0.total_epoch_stake();
assert_eq!(
total_stake,
@ -2605,12 +2567,7 @@ pub mod test {
}
let ancestors = vote_simulator.bank_forks.read().unwrap().ancestors();
let descendants = vote_simulator
.bank_forks
.read()
.unwrap()
.descendants()
.clone();
let descendants = vote_simulator.bank_forks.read().unwrap().descendants();
let mut tower = Tower::default();
tower.record_vote(43, Hash::default());
@ -2679,13 +2636,7 @@ pub mod test {
// Prepare simulated validator restart!
let mut vote_simulator = VoteSimulator::new(2);
let other_vote_account = vote_simulator.vote_pubkeys[1];
let bank0 = vote_simulator
.bank_forks
.read()
.unwrap()
.get(0)
.unwrap()
.clone();
let bank0 = vote_simulator.bank_forks.read().unwrap().get(0).unwrap();
let total_stake = bank0.total_epoch_stake();
let forks = tr(0)
/ (tr(1)
@ -2708,12 +2659,7 @@ pub mod test {
let mut slot_history = SlotHistory::default();
vote_simulator.set_root(replayed_root_slot);
let ancestors = vote_simulator.bank_forks.read().unwrap().ancestors();
let descendants = vote_simulator
.bank_forks
.read()
.unwrap()
.descendants()
.clone();
let descendants = vote_simulator.bank_forks.read().unwrap().descendants();
for slot in &[0, 1, 2, 43, replayed_root_slot] {
slot_history.add(*slot);
}

8
core/src/heaviest_subtree_fork_choice.rs
View File

@ -969,15 +969,11 @@ impl ForkChoice for HeaviestSubtreeForkChoice {
(
r_bank_forks
.get_with_checked_hash(self.best_overall_slot())
.unwrap()
.clone(),
.unwrap(),
self.heaviest_slot_on_same_voted_fork(tower)
.map(|slot_hash| {
// BankForks should only contain one valid version of this slot
r_bank_forks
.get_with_checked_hash(slot_hash)
.unwrap()
.clone()
r_bank_forks.get_with_checked_hash(slot_hash).unwrap()
}),
)
}

48
core/src/optimistic_confirmation_verifier.rs
View File

@ -177,13 +177,7 @@ mod test {
let optimistic_slots = vec![(1, bad_bank_hash), (3, Hash::default())];
optimistic_confirmation_verifier.add_new_optimistic_confirmed_slots(optimistic_slots);
let vote_simulator = setup_forks();
let bank1 = vote_simulator
.bank_forks
.read()
.unwrap()
.get(1)
.cloned()
.unwrap();
let bank1 = vote_simulator.bank_forks.read().unwrap().get(1).unwrap();
assert_eq!(
optimistic_confirmation_verifier
.verify_for_unrooted_optimistic_slots(&bank1, &blockstore),
@ -225,13 +219,7 @@ mod test {
// If root is on same fork, nothing should be returned
optimistic_confirmation_verifier
.add_new_optimistic_confirmed_slots(optimistic_slots.clone());
let bank5 = vote_simulator
.bank_forks
.read()
.unwrap()
.get(5)
.cloned()
.unwrap();
let bank5 = vote_simulator.bank_forks.read().unwrap().get(5).unwrap();
assert!(optimistic_confirmation_verifier
.verify_for_unrooted_optimistic_slots(&bank5, &blockstore)
.is_empty());
@ -241,13 +229,7 @@ mod test {
// If root is on same fork, nothing should be returned
optimistic_confirmation_verifier
.add_new_optimistic_confirmed_slots(optimistic_slots.clone());
let bank3 = vote_simulator
.bank_forks
.read()
.unwrap()
.get(3)
.cloned()
.unwrap();
let bank3 = vote_simulator.bank_forks.read().unwrap().get(3).unwrap();
assert!(optimistic_confirmation_verifier
.verify_for_unrooted_optimistic_slots(&bank3, &blockstore)
.is_empty());
@ -261,13 +243,7 @@ mod test {
// be returned
optimistic_confirmation_verifier
.add_new_optimistic_confirmed_slots(optimistic_slots.clone());
let bank4 = vote_simulator
.bank_forks
.read()
.unwrap()
.get(4)
.cloned()
.unwrap();
let bank4 = vote_simulator.bank_forks.read().unwrap().get(4).unwrap();
assert_eq!(
optimistic_confirmation_verifier
.verify_for_unrooted_optimistic_slots(&bank4, &blockstore),
@ -283,25 +259,13 @@ mod test {
vote_simulator.set_root(5);
// Add a new bank 7 that descends from 6
let bank6 = vote_simulator
.bank_forks
.read()
.unwrap()
.get(6)
.cloned()
.unwrap();
let bank6 = vote_simulator.bank_forks.read().unwrap().get(6).unwrap();
vote_simulator
.bank_forks
.write()
.unwrap()
.insert(Bank::new_from_parent(&bank6, &Pubkey::default(), 7));
let bank7 = vote_simulator
.bank_forks
.read()
.unwrap()
.get(7)
.unwrap()
.clone();
let bank7 = vote_simulator.bank_forks.read().unwrap().get(7).unwrap();
assert!(!bank7.ancestors.contains_key(&3));
// Should return slots 1, 3 as part of the rooted fork because there's no

92
core/src/replay_stage.rs
View File

@ -463,7 +463,7 @@ impl ReplayStage {
let mut replay_active_banks_time = Measure::start("replay_active_banks_time");
let mut ancestors = bank_forks.read().unwrap().ancestors();
let mut descendants = bank_forks.read().unwrap().descendants().clone();
let mut descendants = bank_forks.read().unwrap().descendants();
let did_complete_bank = Self::replay_active_banks(
&blockstore,
&bank_forks,
@ -1519,8 +1519,7 @@ impl ReplayStage {
.read()
.unwrap()
.get(parent_slot)
.expect("parent_slot doesn't exist in bank forks")
.clone();
.expect("parent_slot doesn't exist in bank forks");
assert!(parent.is_frozen());
@ -1768,8 +1767,7 @@ impl ReplayStage {
.read()
.unwrap()
.get(new_root)
.expect("Root bank doesn't exist")
.clone();
.expect("Root bank doesn't exist");
let mut rooted_banks = root_bank.parents();
rooted_banks.push(root_bank.clone());
let rooted_slots: Vec<_> = rooted_banks.iter().map(|bank| bank.slot()).collect();
@ -2155,7 +2153,7 @@ impl ReplayStage {
continue;
}
let bank = bank_forks.read().unwrap().get(*bank_slot).unwrap().clone();
let bank = bank_forks.read().unwrap().get(*bank_slot).unwrap();
let parent_slot = bank.parent_slot();
let prev_leader_slot = progress.get_bank_prev_leader_slot(&bank);
let (num_blocks_on_fork, num_dropped_blocks_on_fork) = {
@ -3322,7 +3320,7 @@ pub mod tests {
// Insert a non-root bank so that the propagation logic will update this
// bank
let bank1 = Bank::new_from_parent(
bank_forks.read().unwrap().get(0).unwrap(),
&bank_forks.read().unwrap().get(0).unwrap(),
&leader_schedule_cache.slot_leader_at(1, None).unwrap(),
1,
);
@ -3422,7 +3420,7 @@ pub mod tests {
let root = 3;
let root_bank = Bank::new_from_parent(
bank_forks.read().unwrap().get(0).unwrap(),
&bank_forks.read().unwrap().get(0).unwrap(),
&Pubkey::default(),
root,
);
@ -3511,20 +3509,20 @@ pub mod tests {
let confirmed_root = 1;
let fork = 2;
let bank1 = Bank::new_from_parent(
bank_forks.read().unwrap().get(0).unwrap(),
&bank_forks.read().unwrap().get(0).unwrap(),
&Pubkey::default(),
confirmed_root,
);
bank_forks.write().unwrap().insert(bank1);
let bank2 = Bank::new_from_parent(
bank_forks.read().unwrap().get(confirmed_root).unwrap(),
&bank_forks.read().unwrap().get(confirmed_root).unwrap(),
&Pubkey::default(),
fork,
);
bank_forks.write().unwrap().insert(bank2);
let root = 3;
let root_bank = Bank::new_from_parent(
bank_forks.read().unwrap().get(confirmed_root).unwrap(),
&bank_forks.read().unwrap().get(confirmed_root).unwrap(),
&Pubkey::default(),
root,
);
@ -3789,12 +3787,12 @@ pub mod tests {
..
} = vote_simulator;
let bank0 = bank_forks.read().unwrap().get(0).cloned().unwrap();
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
assert!(bank0.is_frozen());
assert_eq!(bank0.tick_height(), bank0.max_tick_height());
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
bank_forks.write().unwrap().insert(bank1);
let bank1 = bank_forks.read().unwrap().get(1).cloned().unwrap();
let bank1 = bank_forks.read().unwrap().get(1).unwrap();
let bank1_progress = progress
.entry(bank1.slot())
.or_insert_with(|| ForkProgress::new(bank1.last_blockhash(), None, None, 0, 0));
@ -3910,7 +3908,7 @@ pub mod tests {
.is_none());
for i in 1..=3 {
let prev_bank = bank_forks.read().unwrap().get(i - 1).unwrap().clone();
let prev_bank = bank_forks.read().unwrap().get(i - 1).unwrap();
let bank = Bank::new_from_parent(&prev_bank, &Pubkey::default(), prev_bank.slot() + 1);
let _res = bank.transfer(
10,
@ -3921,7 +3919,7 @@ pub mod tests {
bank.register_tick(&Hash::default());
}
bank_forks.write().unwrap().insert(bank);
let arc_bank = bank_forks.read().unwrap().get(i).unwrap().clone();
let arc_bank = bank_forks.read().unwrap().get(i).unwrap();
leader_vote(i - 1, &arc_bank, &leader_voting_pubkey);
ReplayStage::update_commitment_cache(
arc_bank.clone(),
@ -4056,7 +4054,7 @@ pub mod tests {
vote_simulator::initialize_state(&keypairs, 10_000);
let mut latest_validator_votes_for_frozen_banks =
LatestValidatorVotesForFrozenBanks::default();
let bank0 = bank_forks.get(0).unwrap().clone();
let bank0 = bank_forks.get(0).unwrap();
let my_keypairs = keypairs.get(&my_node_pubkey).unwrap();
let vote_tx = vote_transaction::new_vote_transaction(
vec![0],
@ -4215,20 +4213,8 @@ pub mod tests {
&mut latest_validator_votes_for_frozen_banks,
);
let bank1 = vote_simulator
.bank_forks
.read()
.unwrap()
.get(1)
.unwrap()
.clone();
let bank2 = vote_simulator
.bank_forks
.read()
.unwrap()
.get(2)
.unwrap()
.clone();
let bank1 = vote_simulator.bank_forks.read().unwrap().get(1).unwrap();
let bank2 = vote_simulator.bank_forks.read().unwrap().get(2).unwrap();
assert_eq!(
heaviest_subtree_fork_choice
.stake_voted_subtree(&(1, bank1.hash()))
@ -4530,9 +4516,9 @@ pub mod tests {
let (mut bank_forks, mut progress_map, _) =
vote_simulator::initialize_state(&keypairs, stake);
let bank0 = bank_forks.get(0).unwrap().clone();
let bank0 = bank_forks.get(0).unwrap();
bank_forks.insert(Bank::new_from_parent(&bank0, &Pubkey::default(), 9));
let bank9 = bank_forks.get(9).unwrap().clone();
let bank9 = bank_forks.get(9).unwrap();
bank_forks.insert(Bank::new_from_parent(&bank9, &Pubkey::default(), 10));
bank_forks.set_root(9, &AbsRequestSender::default(), None);
let total_epoch_stake = bank0.total_epoch_stake();
@ -4859,7 +4845,7 @@ pub mod tests {
Bank::new_from_parent(&Arc::new(bank0), &Pubkey::default(), parent_slot);
let mut bank_forks = BankForks::new(parent_slot_bank);
let bank5 =
Bank::new_from_parent(bank_forks.get(parent_slot).unwrap(), &Pubkey::default(), 5);
Bank::new_from_parent(&bank_forks.get(parent_slot).unwrap(), &Pubkey::default(), 5);
bank_forks.insert(bank5);
// Should purge only `previous_leader_slot` from the progress map
@ -4970,14 +4956,14 @@ pub mod tests {
// Create bank 7
let root_bank = bank_forks.read().unwrap().root_bank();
let bank7 = Bank::new_from_parent(
&bank_forks.read().unwrap().get(6).unwrap().clone(),
&bank_forks.read().unwrap().get(6).unwrap(),
&Pubkey::default(),
7,
);
bank_forks.write().unwrap().insert(bank7);
blockstore.add_tree(tr(6) / tr(7), false, false, 3, Hash::default());
let bank7 = bank_forks.read().unwrap().get(7).unwrap().clone();
let mut descendants = bank_forks.read().unwrap().descendants().clone();
let bank7 = bank_forks.read().unwrap().get(7).unwrap();
let mut descendants = bank_forks.read().unwrap().descendants();
let mut ancestors = bank_forks.read().unwrap().ancestors();
// Process a transfer on bank 7
@ -4995,7 +4981,7 @@ pub mod tests {
// Process a vote for slot 0 in bank 5
let validator0_keypairs = &validator_keypairs.get(&sender).unwrap();
let bank0 = bank_forks.read().unwrap().get(0).unwrap().clone();
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
let vote_tx = vote_transaction::new_vote_transaction(
vec![0],
bank0.hash(),
@ -5053,7 +5039,7 @@ pub mod tests {
assert_eq!(bank7.get_balance(&sender), old_balance);
// Purging slot 4 should purge only slot 4
let mut descendants = bank_forks.read().unwrap().descendants().clone();
let mut descendants = bank_forks.read().unwrap().descendants();
let mut ancestors = bank_forks.read().unwrap().ancestors();
ReplayStage::purge_unconfirmed_duplicate_slot(
4,
@ -5076,7 +5062,7 @@ pub mod tests {
}
// Purging slot 1 should purge both forks 2 and 3
let mut descendants = bank_forks.read().unwrap().descendants().clone();
let mut descendants = bank_forks.read().unwrap().descendants();
let mut ancestors = bank_forks.read().unwrap().ancestors();
ReplayStage::purge_unconfirmed_duplicate_slot(
1,
@ -5101,7 +5087,7 @@ pub mod tests {
let (VoteSimulator { bank_forks, .. }, _) = setup_default_forks(1, None::<GenerateVotes>);
// Purge branch rooted at slot 2
let mut descendants = bank_forks.read().unwrap().descendants().clone();
let mut descendants = bank_forks.read().unwrap().descendants();
let mut ancestors = bank_forks.read().unwrap().ancestors();
let slot_2_descendants = descendants.get(&2).unwrap().clone();
ReplayStage::purge_ancestors_descendants(
@ -5123,7 +5109,7 @@ pub mod tests {
));
assert!(check_map_eq(
&descendants,
bank_forks.read().unwrap().descendants()
&bank_forks.read().unwrap().descendants()
));
// Try to purge the root
@ -5131,7 +5117,7 @@ pub mod tests {
.write()
.unwrap()
.set_root(3, &AbsRequestSender::default(), None);
let mut descendants = bank_forks.read().unwrap().descendants().clone();
let mut descendants = bank_forks.read().unwrap().descendants();
let mut ancestors = bank_forks.read().unwrap().ancestors();
let slot_3_descendants = descendants.get(&3).unwrap().clone();
ReplayStage::purge_ancestors_descendants(
@ -5275,7 +5261,7 @@ pub mod tests {
// Record the vote for 4
tower.record_bank_vote(
bank_forks.read().unwrap().get(4).unwrap(),
&bank_forks.read().unwrap().get(4).unwrap(),
&Pubkey::default(),
);
@ -5411,7 +5397,7 @@ pub mod tests {
let (mut ancestors, mut descendants) = {
let r_bank_forks = bank_forks.read().unwrap();
(r_bank_forks.ancestors(), r_bank_forks.descendants().clone())
(r_bank_forks.ancestors(), r_bank_forks.descendants())
};
// Insert different versions of both 1 and 2. Both slots 1 and 2 should
@ -5490,7 +5476,7 @@ pub mod tests {
} = vote_simulator;
tower.record_bank_vote(
bank_forks.read().unwrap().get(first_vote).unwrap(),
&bank_forks.read().unwrap().get(first_vote).unwrap(),
&Pubkey::default(),
);
@ -5528,7 +5514,7 @@ pub mod tests {
duplicate_confirmed_bank2_hash
);
let mut ancestors = bank_forks.read().unwrap().ancestors();
let mut descendants = bank_forks.read().unwrap().descendants().clone();
let mut descendants = bank_forks.read().unwrap().descendants();
let old_descendants_of_2 = descendants.get(&2).unwrap().clone();
ReplayStage::dump_then_repair_correct_slots(
@ -5584,7 +5570,7 @@ pub mod tests {
.collect();
let ancestors = bank_forks.read().unwrap().ancestors();
let descendants = bank_forks.read().unwrap().descendants().clone();
let descendants = bank_forks.read().unwrap().descendants();
ReplayStage::compute_bank_stats(
&Pubkey::new_unique(),
@ -5711,7 +5697,7 @@ pub mod tests {
.collect();
let ancestors = bank_forks.read().unwrap().ancestors();
let descendants = bank_forks.read().unwrap().descendants().clone();
let descendants = bank_forks.read().unwrap().descendants();
ReplayStage::compute_bank_stats(
&Pubkey::new_unique(),
@ -5821,7 +5807,7 @@ pub mod tests {
// Cast a vote for slot 3 on one fork
let vote_slot = 3;
let vote_bank = bank_forks.read().unwrap().get(vote_slot).unwrap().clone();
let vote_bank = bank_forks.read().unwrap().get(vote_slot).unwrap();
gossip_verified_vote_hash_sender
.send((vote_pubkey, vote_slot, vote_bank.hash()))
.expect("Send should succeed");
@ -5873,7 +5859,7 @@ pub mod tests {
validator_keypairs.remove(&my_pubkey).unwrap().vote_keypair,
)];
let my_vote_pubkey = my_vote_keypair[0].pubkey();
let bank0 = bank_forks.read().unwrap().get(0).unwrap().clone();
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
let (voting_sender, voting_receiver) = unbounded();
@ -6139,7 +6125,7 @@ pub mod tests {
let (retransmit_slots_sender, retransmit_slots_receiver) = unbounded();
let bank1 = Bank::new_from_parent(
bank_forks.read().unwrap().get(0).unwrap(),
&bank_forks.read().unwrap().get(0).unwrap(),
&leader_schedule_cache.slot_leader_at(1, None).unwrap(),
1,
);
@ -6310,7 +6296,7 @@ pub mod tests {
let mut prev_index = 0;
for i in (1..10).chain(11..15) {
let bank = Bank::new_from_parent(
bank_forks.read().unwrap().get(prev_index).unwrap(),
&bank_forks.read().unwrap().get(prev_index).unwrap(),
&leader_schedule_cache.slot_leader_at(i, None).unwrap(),
i,
);
@ -6382,7 +6368,7 @@ pub mod tests {
.cloned()
.collect();
let ancestors = &bank_forks.read().unwrap().ancestors();
let descendants = &bank_forks.read().unwrap().descendants().clone();
let descendants = &bank_forks.read().unwrap().descendants();
ReplayStage::compute_bank_stats(
&Pubkey::default(),
&bank_forks.read().unwrap().ancestors(),

7
core/src/vote_simulator.rs
View File

@ -79,7 +79,7 @@ impl VoteSimulator {
continue;
}
let parent = *walk.get_parent().unwrap().data();
let parent_bank = self.bank_forks.read().unwrap().get(parent).unwrap().clone();
let parent_bank = self.bank_forks.read().unwrap().get(parent).unwrap();
let new_bank = Bank::new_from_parent(&parent_bank, &Pubkey::default(), slot);
self.progress
.entry(slot)
@ -171,11 +171,10 @@ impl VoteSimulator {
.read()
.unwrap()
.get(vote_slot)
.expect("Bank must have been created before vote simulation")
.clone();
.expect("Bank must have been created before vote simulation");
// Try to vote on the given slot
let descendants = self.bank_forks.read().unwrap().descendants().clone();
let descendants = self.bank_forks.read().unwrap().descendants();
let SelectVoteAndResetForkResult {
heaviest_fork_failures,
..

20
core/tests/snapshots.rs
View File

@ -216,11 +216,8 @@ mod tests {
)
.unwrap();
let bank = old_bank_forks
.get(deserialized_bank.slot())
.unwrap()
.clone();
assert_eq!(*bank, deserialized_bank);
let bank = old_bank_forks.get(deserialized_bank.slot()).unwrap();
assert_eq!(bank.as_ref(), &deserialized_bank);
}
// creates banks up to "last_slot" and runs the input function `f` on each bank created
@ -279,7 +276,7 @@ mod tests {
snapshot_utils::get_highest_bank_snapshot_pre(bank_snapshots_dir)
.expect("no bank snapshots found in path");
let accounts_package = AccountsPackage::new(
last_bank,
&last_bank,
&last_bank_snapshot_info,
bank_snapshots_dir,
last_bank.src.slot_deltas(&last_bank.src.roots()),
@ -370,7 +367,7 @@ mod tests {
// Take snapshot of zeroth bank
let bank0 = bank_forks.get(0).unwrap();
let storages = bank0.get_snapshot_storages(None);
snapshot_utils::add_bank_snapshot(bank_snapshots_dir, bank0, &storages, snapshot_version)
snapshot_utils::add_bank_snapshot(bank_snapshots_dir, &bank0, &storages, snapshot_version)
.unwrap();
// Set up snapshotting channels
@ -972,7 +969,7 @@ mod tests {
// Make a new bank and perform some transactions
let bank = {
let bank = Bank::new_from_parent(
bank_forks.read().unwrap().get(slot - 1).unwrap(),
&bank_forks.read().unwrap().get(slot - 1).unwrap(),
&Pubkey::default(),
slot,
);
@ -1035,14 +1032,15 @@ mod tests {
)
.unwrap();
assert_eq!(deserialized_bank.slot(), LAST_SLOT,);
assert_eq!(deserialized_bank.slot(), LAST_SLOT);
assert_eq!(
deserialized_bank,
**bank_forks
&deserialized_bank,
bank_forks
.read()
.unwrap()
.get(deserialized_bank.slot())
.unwrap()
.as_ref()
);
// Stop the background services

9
ledger-tool/src/main.rs
View File

@ -2315,8 +2315,7 @@ fn main() {
.unwrap_or_else(|| {
eprintln!("Error: Slot {} is not available", snapshot_slot);
exit(1);
})
.clone();
});
let child_bank_required = rent_burn_percentage.is_ok()
|| hashes_per_tick.is_some()
@ -2913,7 +2912,7 @@ fn main() {
}
};
let warped_bank = Bank::new_from_parent_with_tracer(
base_bank,
&base_bank,
base_bank.collector_id(),
next_epoch,
tracer,
@ -2930,7 +2929,7 @@ fn main() {
println!("Slot: {} => {}", base_bank.slot(), warped_bank.slot());
println!("Epoch: {} => {}", base_bank.epoch(), warped_bank.epoch());
assert_capitalization(base_bank);
assert_capitalization(&base_bank);
assert_capitalization(&warped_bank);
let interest_per_epoch = ((warped_bank.capitalization() as f64)
/ (base_bank.capitalization() as f64)
@ -3177,7 +3176,7 @@ fn main() {
);
}
assert_capitalization(bank);
assert_capitalization(&bank);
println!("Inflation: {:?}", bank.inflation());
println!("RentCollector: {:?}", bank.rent_collector());
println!("Capitalization: {}", Sol(bank.capitalization()));

6
ledger/src/blockstore_processor.rs
View File

@ -733,7 +733,7 @@ pub fn process_blockstore_from_root(
info!("ledger processing timing: {:?}", timing);
{
let bank_forks = bank_forks.read().unwrap();
let mut bank_slots = bank_forks.banks().keys().collect::<Vec<_>>();
let mut bank_slots = bank_forks.banks().keys().copied().collect::<Vec<_>>();
bank_slots.sort_unstable();
info!(
@ -1165,7 +1165,7 @@ fn load_frozen_forks(
);
process_next_slots(
bank_forks.read().unwrap().get(start_slot).unwrap(),
&bank_forks.read().unwrap().get(start_slot).unwrap(),
start_slot_meta,
blockstore,
leader_schedule_cache,
@ -3118,7 +3118,7 @@ pub mod tests {
// Set up bank1
let mut bank_forks = BankForks::new(Bank::new_for_tests(&genesis_config));
let bank0 = bank_forks.get(0).unwrap().clone();
let bank0 = bank_forks.get(0).unwrap();
let opts = ProcessOptions {
poh_verify: true,
accounts_db_test_hash_calculation: true,

20
rpc/src/optimistically_confirmed_bank_tracker.rs
View File

@ -217,7 +217,7 @@ impl OptimisticallyConfirmedBankTracker {
Self::notify_or_defer_confirmed_banks(
subscriptions,
bank_forks,
bank,
&bank,
*highest_confirmed_slot,
last_notified_confirmed_slot,
pending_optimistically_confirmed_banks,
@ -330,13 +330,13 @@ mod tests {
let GenesisConfigInfo { genesis_config, .. } = create_genesis_config(100);
let bank = Bank::new_for_tests(&genesis_config);
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let bank0 = bank_forks.read().unwrap().get(0).unwrap().clone();
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
bank_forks.write().unwrap().insert(bank1);
let bank1 = bank_forks.read().unwrap().get(1).unwrap().clone();
let bank1 = bank_forks.read().unwrap().get(1).unwrap();
let bank2 = Bank::new_from_parent(&bank1, &Pubkey::default(), 2);
bank_forks.write().unwrap().insert(bank2);
let bank2 = bank_forks.read().unwrap().get(2).unwrap().clone();
let bank2 = bank_forks.read().unwrap().get(2).unwrap();
let bank3 = Bank::new_from_parent(&bank2, &Pubkey::default(), 3);
bank_forks.write().unwrap().insert(bank3);
@ -402,7 +402,7 @@ mod tests {
assert_eq!(highest_confirmed_slot, 3);
// Test bank will only be cached when frozen
let bank3 = bank_forks.read().unwrap().get(3).unwrap().clone();
let bank3 = bank_forks.read().unwrap().get(3).unwrap();
bank3.freeze();
OptimisticallyConfirmedBankTracker::process_notification(
@ -420,7 +420,7 @@ mod tests {
assert_eq!(pending_optimistically_confirmed_banks.len(), 0);
// Test higher root will be cached and clear pending_optimistically_confirmed_banks
let bank3 = bank_forks.read().unwrap().get(3).unwrap().clone();
let bank3 = bank_forks.read().unwrap().get(3).unwrap();
let bank4 = Bank::new_from_parent(&bank3, &Pubkey::default(), 4);
bank_forks.write().unwrap().insert(bank4);
OptimisticallyConfirmedBankTracker::process_notification(
@ -438,10 +438,10 @@ mod tests {
assert!(pending_optimistically_confirmed_banks.contains(&4));
assert_eq!(highest_confirmed_slot, 4);
let bank4 = bank_forks.read().unwrap().get(4).unwrap().clone();
let bank4 = bank_forks.read().unwrap().get(4).unwrap();
let bank5 = Bank::new_from_parent(&bank4, &Pubkey::default(), 5);
bank_forks.write().unwrap().insert(bank5);
let bank5 = bank_forks.read().unwrap().get(5).unwrap().clone();
let bank5 = bank_forks.read().unwrap().get(5).unwrap();
OptimisticallyConfirmedBankTracker::process_notification(
BankNotification::Root(bank5),
&bank_forks,
@ -458,10 +458,10 @@ mod tests {
assert_eq!(highest_confirmed_slot, 4);
// Banks <= root do not get added to pending list, even if not frozen
let bank5 = bank_forks.read().unwrap().get(5).unwrap().clone();
let bank5 = bank_forks.read().unwrap().get(5).unwrap();
let bank6 = Bank::new_from_parent(&bank5, &Pubkey::default(), 6);
bank_forks.write().unwrap().insert(bank6);
let bank5 = bank_forks.read().unwrap().get(5).unwrap().clone();
let bank5 = bank_forks.read().unwrap().get(5).unwrap();
let bank7 = Bank::new_from_parent(&bank5, &Pubkey::default(), 7);
bank_forks.write().unwrap().insert(bank7);
bank_forks

13
rpc/src/rpc.rs
View File

@ -250,7 +250,7 @@ impl JsonRpcRequestProcessor {
CommitmentLevel::SingleGossip | CommitmentLevel::Confirmed => unreachable!(), // SingleGossip variant is deprecated
};
r_bank_forks.get(slot).cloned().unwrap_or_else(|| {
r_bank_forks.get(slot).unwrap_or_else(|| {
// We log a warning instead of returning an error, because all known error cases
// are due to known bugs that should be fixed instead.
//
@ -1066,8 +1066,7 @@ impl JsonRpcRequestProcessor {
|| confirmed_block.block_height.is_none()
{
let r_bank_forks = self.bank_forks.read().unwrap();
let bank = r_bank_forks.get(slot).cloned();
if let Some(bank) = bank {
if let Some(bank) = r_bank_forks.get(slot) {
if confirmed_block.block_time.is_none() {
confirmed_block.block_time =
Some(bank.clock().unix_timestamp);
@ -7643,13 +7642,13 @@ pub mod tests {
let bank = Bank::new_for_tests(&genesis_config);
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let bank0 = bank_forks.read().unwrap().get(0).unwrap().clone();
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
bank_forks.write().unwrap().insert(bank1);
let bank1 = bank_forks.read().unwrap().get(1).unwrap().clone();
let bank1 = bank_forks.read().unwrap().get(1).unwrap();
let bank2 = Bank::new_from_parent(&bank1, &Pubkey::default(), 2);
bank_forks.write().unwrap().insert(bank2);
let bank2 = bank_forks.read().unwrap().get(2).unwrap().clone();
let bank2 = bank_forks.read().unwrap().get(2).unwrap();
let bank3 = Bank::new_from_parent(&bank2, &Pubkey::default(), 3);
bank_forks.write().unwrap().insert(bank3);
@ -7750,7 +7749,7 @@ pub mod tests {
assert_eq!(slot, 2);
// Test freezing an optimistically confirmed bank will update cache
let bank3 = bank_forks.read().unwrap().get(3).unwrap().clone();
let bank3 = bank_forks.read().unwrap().get(3).unwrap();
OptimisticallyConfirmedBankTracker::process_notification(
BankNotification::Frozen(bank3),
&bank_forks,

6
rpc/src/rpc_pubsub.rs
View File

@ -838,7 +838,7 @@ mod tests {
let bank = Bank::new_for_tests(&genesis_config);
let blockhash = bank.last_blockhash();
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let bank0 = bank_forks.read().unwrap().get(0).unwrap().clone();
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
bank_forks.write().unwrap().insert(bank1);
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
@ -964,7 +964,7 @@ mod tests {
let bank = Bank::new_for_tests(&genesis_config);
let blockhash = bank.last_blockhash();
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let bank0 = bank_forks.read().unwrap().get(0).unwrap().clone();
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
bank_forks.write().unwrap().insert(bank1);
let max_complete_transaction_status_slot = Arc::new(AtomicU64::default());
@ -1152,7 +1152,7 @@ mod tests {
let bank = Bank::new_for_tests(&genesis_config);
let blockhash = bank.last_blockhash();
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let bank0 = bank_forks.read().unwrap().get(0).unwrap().clone();
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
bank_forks.write().unwrap().insert(bank1);
let bob = Keypair::new();

34
rpc/src/rpc_subscriptions.rs
View File

@ -145,7 +145,7 @@ where
X: Clone + Default,
{
let mut notified = false;
if let Some(bank) = bank_forks.read().unwrap().get(slot).cloned() {
if let Some(bank) = bank_forks.read().unwrap().get(slot) {
let results = bank_method(&bank, params);
let mut w_last_notified_slot = subscription.last_notified_slot.write().unwrap();
let (filter_results, result_slot) =
@ -1262,7 +1262,7 @@ pub(crate) mod tests {
let bank = Bank::new_for_tests(&genesis_config);
let blockhash = bank.last_blockhash();
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let bank0 = bank_forks.read().unwrap().get(0).unwrap().clone();
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
bank_forks.write().unwrap().insert(bank1);
let alice = Keypair::new();
@ -1839,10 +1839,10 @@ pub(crate) mod tests {
let blockhash = bank.last_blockhash();
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let bank0 = bank_forks.read().unwrap().get(0).unwrap().clone();
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
bank_forks.write().unwrap().insert(bank1);
let bank1 = bank_forks.read().unwrap().get(1).unwrap().clone();
let bank1 = bank_forks.read().unwrap().get(1).unwrap();
// add account for alice and process the transaction at bank1
let alice = Keypair::new();
@ -1870,7 +1870,7 @@ pub(crate) mod tests {
16,
&stake::program::id(),
);
let bank2 = bank_forks.read().unwrap().get(2).unwrap().clone();
let bank2 = bank_forks.read().unwrap().get(2).unwrap();
bank2.process_transaction(&tx).unwrap();
@ -1887,7 +1887,7 @@ pub(crate) mod tests {
16,
&stake::program::id(),
);
let bank3 = bank_forks.read().unwrap().get(3).unwrap().clone();
let bank3 = bank_forks.read().unwrap().get(3).unwrap();
bank3.process_transaction(&tx).unwrap();
@ -2026,10 +2026,10 @@ pub(crate) mod tests {
let blockhash = bank.last_blockhash();
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let bank0 = bank_forks.read().unwrap().get(0).unwrap().clone();
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
bank_forks.write().unwrap().insert(bank1);
let bank1 = bank_forks.read().unwrap().get(1).unwrap().clone();
let bank1 = bank_forks.read().unwrap().get(1).unwrap();
// add account for alice and process the transaction at bank1
let alice = Keypair::new();
@ -2057,7 +2057,7 @@ pub(crate) mod tests {
16,
&stake::program::id(),
);
let bank2 = bank_forks.read().unwrap().get(2).unwrap().clone();
let bank2 = bank_forks.read().unwrap().get(2).unwrap();
bank2.process_transaction(&tx).unwrap();
@ -2137,10 +2137,10 @@ pub(crate) mod tests {
let blockhash = bank.last_blockhash();
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let bank0 = bank_forks.read().unwrap().get(0).unwrap().clone();
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
bank_forks.write().unwrap().insert(bank1);
let bank1 = bank_forks.read().unwrap().get(1).unwrap().clone();
let bank1 = bank_forks.read().unwrap().get(1).unwrap();
// add account for alice and process the transaction at bank1
let alice = Keypair::new();
@ -2168,7 +2168,7 @@ pub(crate) mod tests {
16,
&stake::program::id(),
);
let bank2 = bank_forks.read().unwrap().get(2).unwrap().clone();
let bank2 = bank_forks.read().unwrap().get(2).unwrap();
bank2.process_transaction(&tx).unwrap();
@ -2265,7 +2265,7 @@ pub(crate) mod tests {
16,
&stake::program::id(),
);
let bank3 = bank_forks.read().unwrap().get(3).unwrap().clone();
let bank3 = bank_forks.read().unwrap().get(3).unwrap();
bank3.process_transaction(&tx).unwrap();
bank3.freeze();
@ -2330,7 +2330,7 @@ pub(crate) mod tests {
.unwrap();
let next_bank = Bank::new_from_parent(
&bank_forks.get(0).unwrap().clone(),
&bank_forks.get(0).unwrap(),
&solana_sdk::pubkey::new_rand(),
1,
);
@ -2630,7 +2630,7 @@ pub(crate) mod tests {
let bank = Bank::new_for_tests(&genesis_config);
let blockhash = bank.last_blockhash();
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank)));
let bank0 = bank_forks.read().unwrap().get(0).unwrap().clone();
let bank0 = bank_forks.read().unwrap().get(0).unwrap();
let bank1 = Bank::new_from_parent(&bank0, &Pubkey::default(), 1);
bank_forks.write().unwrap().insert(bank1);
let bank2 = Bank::new_from_parent(&bank0, &Pubkey::default(), 2);
@ -2677,7 +2677,7 @@ pub(crate) mod tests {
);
// Add the transaction to the 1st bank and then freeze the bank
let bank1 = bank_forks.write().unwrap().get(1).cloned().unwrap();
let bank1 = bank_forks.write().unwrap().get(1).unwrap();
bank1.process_transaction(&tx).unwrap();
bank1.freeze();
@ -2752,7 +2752,7 @@ pub(crate) mod tests {
)
.unwrap();
let bank2 = bank_forks.read().unwrap().get(2).unwrap().clone();
let bank2 = bank_forks.read().unwrap().get(2).unwrap();
bank2.freeze();
highest_confirmed_slot = 0;
OptimisticallyConfirmedBankTracker::process_notification(

34
runtime/src/bank_forks.rs
View File

@ -63,8 +63,8 @@ impl BankForks {
Self::new_from_banks(&[Arc::new(bank)], root)
}
pub fn banks(&self) -> &HashMap<Slot, Arc<Bank>> {
&self.banks
pub fn banks(&self) -> HashMap<Slot, Arc<Bank>> {
self.banks.clone()
}
/// Create a map of bank slot id to the set of ancestors for the bank slot.
@ -80,8 +80,8 @@ impl BankForks {
}
/// Create a map of bank slot id to the set of all of its descendants
pub fn descendants(&self) -> &HashMap<Slot, HashSet<Slot>> {
&self.descendants
pub fn descendants(&self) -> HashMap<Slot, HashSet<Slot>> {
self.descendants.clone()
}
pub fn frozen_banks(&self) -> HashMap<Slot, Arc<Bank>> {
@ -100,16 +100,16 @@ impl BankForks {
.collect()
}
pub fn get(&self, bank_slot: Slot) -> Option<&Arc<Bank>> {
self.banks.get(&bank_slot)
pub fn get(&self, bank_slot: Slot) -> Option<Arc<Bank>> {
self.banks.get(&bank_slot).cloned()
}
pub fn get_with_checked_hash(
&self,
(bank_slot, expected_hash): (Slot, Hash),
) -> Option<&Arc<Bank>> {
let maybe_bank = self.banks.get(&bank_slot);
if let Some(bank) = maybe_bank {
) -> Option<Arc<Bank>> {
let maybe_bank = self.get(bank_slot);
if let Some(bank) = &maybe_bank {
assert_eq!(bank.hash(), expected_hash);
}
maybe_bank
@ -506,10 +506,6 @@ impl BankForks {
self.snapshot_config = snapshot_config;
}
pub fn snapshot_config(&self) -> &Option<SnapshotConfig> {
&self.snapshot_config
}
pub fn set_accounts_hash_interval_slots(&mut self, accounts_interval_slots: u64) {
self.accounts_hash_interval_slots = accounts_interval_slots;
}
@ -707,7 +703,7 @@ mod tests {
])
);
assert_eq!(
*bank_forks.descendants(),
bank_forks.descendants(),
make_hash_map(vec![
(0, vec![1, 2, 3, 4]),
(1, vec![2]),
@ -724,7 +720,7 @@ mod tests {
banks[2].squash();
assert_eq!(bank_forks.ancestors(), make_hash_map(vec![(2, vec![]),]));
assert_eq!(
*bank_forks.descendants(),
bank_forks.descendants(),
make_hash_map(vec![(0, vec![2]), (1, vec![2]), (2, vec![]),])
);
banks.push(bank_forks.insert(Bank::new_from_parent(&banks[2], &Pubkey::default(), 5)));
@ -734,7 +730,7 @@ mod tests {
make_hash_map(vec![(2, vec![]), (5, vec![2]), (6, vec![2, 5])])
);
assert_eq!(
*bank_forks.descendants(),
bank_forks.descendants(),
make_hash_map(vec![
(0, vec![2]),
(1, vec![2]),
@ -766,7 +762,7 @@ mod tests {
])
);
assert_eq!(
*bank_forks.descendants(),
bank_forks.descendants(),
make_hash_map(vec![
(0, vec![1, 2, 3, 4]),
(1, vec![2]),
@ -786,7 +782,7 @@ mod tests {
make_hash_map(vec![(1, vec![]), (2, vec![]),])
);
assert_eq!(
*bank_forks.descendants(),
bank_forks.descendants(),
make_hash_map(vec![(0, vec![1, 2]), (1, vec![2]), (2, vec![]),])
);
banks.push(bank_forks.insert(Bank::new_from_parent(&banks[2], &Pubkey::default(), 5)));
@ -801,7 +797,7 @@ mod tests {
])
);
assert_eq!(
*bank_forks.descendants(),
bank_forks.descendants(),
make_hash_map(vec![
(0, vec![1, 2]),
(1, vec![2]),