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

Allow fork choice to support multiple versions of a slot (#16266)

This commit is contained in:
carllin 2021-04-12 01:00:59 -07:00 committed by GitHub
parent ef30943c5c
commit dc7030ffaa
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 2034 additions and 637 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

97
core/src/cluster_slot_state_verifier.rs
View File

@ -18,9 +18,13 @@ pub enum SlotStateUpdate {
#[derive(PartialEq, Debug)] #[derive(PartialEq, Debug)]
pub enum ResultingStateChange { pub enum ResultingStateChange {
MarkSlotDuplicate, // Hash of our current frozen version of the slot
MarkSlotDuplicate(Hash),
// Hash of the cluster confirmed slot that is not equivalent
// to our frozen version of the slot
RepairDuplicateConfirmedVersion(Hash), RepairDuplicateConfirmedVersion(Hash),
DuplicateConfirmedSlotMatchesCluster, // Hash of our current frozen version of the slot
DuplicateConfirmedSlotMatchesCluster(Hash),
} }
impl SlotStateUpdate { impl SlotStateUpdate {
@ -56,9 +60,9 @@ fn on_dead_slot(
// No need to check `is_slot_duplicate` and modify fork choice as dead slots // No need to check `is_slot_duplicate` and modify fork choice as dead slots
// are never frozen, and thus never added to fork choice. The state change for // are never frozen, and thus never added to fork choice. The state change for
// `MarkSlotDuplicate` will try to modify fork choice, but won't find the slot // `MarkSlotDuplicate` will try to modify fork choice, but won't find the slot
// in the fork choice tree, so is equivalent to a // in the fork choice tree, so is equivalent to a no-op
return vec![ return vec![
ResultingStateChange::MarkSlotDuplicate, ResultingStateChange::MarkSlotDuplicate(Hash::default()),
ResultingStateChange::RepairDuplicateConfirmedVersion( ResultingStateChange::RepairDuplicateConfirmedVersion(
*cluster_duplicate_confirmed_hash, *cluster_duplicate_confirmed_hash,
), ),
@ -92,7 +96,7 @@ fn on_frozen_slot(
slot, cluster_duplicate_confirmed_hash, bank_frozen_hash slot, cluster_duplicate_confirmed_hash, bank_frozen_hash
); );
return vec![ return vec![
ResultingStateChange::MarkSlotDuplicate, ResultingStateChange::MarkSlotDuplicate(*bank_frozen_hash),
ResultingStateChange::RepairDuplicateConfirmedVersion( ResultingStateChange::RepairDuplicateConfirmedVersion(
*cluster_duplicate_confirmed_hash, *cluster_duplicate_confirmed_hash,
), ),
@ -101,7 +105,9 @@ fn on_frozen_slot(
// If the versions match, then add the slot to the candidate // If the versions match, then add the slot to the candidate
// set to account for the case where it was removed earlier // set to account for the case where it was removed earlier
// by the `on_duplicate_slot()` handler // by the `on_duplicate_slot()` handler
return vec![ResultingStateChange::DuplicateConfirmedSlotMatchesCluster]; return vec![ResultingStateChange::DuplicateConfirmedSlotMatchesCluster(
*bank_frozen_hash,
)];
} }
} }
@ -115,7 +121,7 @@ fn on_frozen_slot(
// 2) A gossip duplicate_confirmed version that didn't match our frozen // 2) A gossip duplicate_confirmed version that didn't match our frozen
// version. // version.
// In both cases, mark the progress map for this slot as duplicate // In both cases, mark the progress map for this slot as duplicate
return vec![ResultingStateChange::MarkSlotDuplicate]; return vec![ResultingStateChange::MarkSlotDuplicate(*bank_frozen_hash)];
} }
vec![] vec![]
@ -202,12 +208,12 @@ fn apply_state_changes(
) { ) {
for state_change in state_changes { for state_change in state_changes {
match state_change { match state_change {
ResultingStateChange::MarkSlotDuplicate => { ResultingStateChange::MarkSlotDuplicate(bank_frozen_hash) => {
progress.set_unconfirmed_duplicate_slot( progress.set_unconfirmed_duplicate_slot(
slot, slot,
descendants.get(&slot).unwrap_or(&HashSet::default()), descendants.get(&slot).unwrap_or(&HashSet::default()),
); );
fork_choice.mark_fork_invalid_candidate(slot); fork_choice.mark_fork_invalid_candidate(&(slot, bank_frozen_hash));
} }
ResultingStateChange::RepairDuplicateConfirmedVersion( ResultingStateChange::RepairDuplicateConfirmedVersion(
cluster_duplicate_confirmed_hash, cluster_duplicate_confirmed_hash,
@ -216,13 +222,13 @@ fn apply_state_changes(
// progress map from ReplayStage::confirm_forks to here. // progress map from ReplayStage::confirm_forks to here.
repair_correct_version(slot, &cluster_duplicate_confirmed_hash); repair_correct_version(slot, &cluster_duplicate_confirmed_hash);
} }
ResultingStateChange::DuplicateConfirmedSlotMatchesCluster => { ResultingStateChange::DuplicateConfirmedSlotMatchesCluster(bank_frozen_hash) => {
progress.set_confirmed_duplicate_slot( progress.set_confirmed_duplicate_slot(
slot, slot,
ancestors.get(&slot).unwrap_or(&HashSet::default()), ancestors.get(&slot).unwrap_or(&HashSet::default()),
descendants.get(&slot).unwrap_or(&HashSet::default()), descendants.get(&slot).unwrap_or(&HashSet::default()),
); );
fork_choice.mark_fork_valid_candidate(slot); fork_choice.mark_fork_valid_candidate(&(slot, bank_frozen_hash));
} }
} }
} }
@ -388,7 +394,7 @@ mod test {
is_slot_duplicate, is_slot_duplicate,
is_dead is_dead
), ),
vec![ResultingStateChange::MarkSlotDuplicate] vec![ResultingStateChange::MarkSlotDuplicate(bank_frozen_hash)]
); );
} }
@ -426,7 +432,9 @@ mod test {
is_slot_duplicate, is_slot_duplicate,
is_dead is_dead
), ),
vec![ResultingStateChange::DuplicateConfirmedSlotMatchesCluster,] vec![ResultingStateChange::DuplicateConfirmedSlotMatchesCluster(
bank_frozen_hash
),]
); );
// If the cluster_duplicate_confirmed_hash does not match, then we // If the cluster_duplicate_confirmed_hash does not match, then we
@ -443,7 +451,7 @@ mod test {
is_dead is_dead
), ),
vec![ vec![
ResultingStateChange::MarkSlotDuplicate, ResultingStateChange::MarkSlotDuplicate(bank_frozen_hash),
ResultingStateChange::RepairDuplicateConfirmedVersion(mismatched_hash), ResultingStateChange::RepairDuplicateConfirmedVersion(mismatched_hash),
] ]
); );
@ -483,7 +491,7 @@ mod test {
is_slot_duplicate, is_slot_duplicate,
is_dead is_dead
), ),
vec![ResultingStateChange::MarkSlotDuplicate,] vec![ResultingStateChange::MarkSlotDuplicate(bank_frozen_hash),]
); );
// If the cluster_duplicate_confirmed_hash matches, we just confirm // If the cluster_duplicate_confirmed_hash matches, we just confirm
@ -497,7 +505,9 @@ mod test {
is_slot_duplicate, is_slot_duplicate,
is_dead is_dead
), ),
vec![ResultingStateChange::DuplicateConfirmedSlotMatchesCluster,] vec![ResultingStateChange::DuplicateConfirmedSlotMatchesCluster(
bank_frozen_hash
),]
); );
// If the cluster_duplicate_confirmed_hash does not match, then we // If the cluster_duplicate_confirmed_hash does not match, then we
@ -514,7 +524,7 @@ mod test {
is_dead is_dead
), ),
vec![ vec![
ResultingStateChange::MarkSlotDuplicate, ResultingStateChange::MarkSlotDuplicate(bank_frozen_hash),
ResultingStateChange::RepairDuplicateConfirmedVersion(mismatched_hash), ResultingStateChange::RepairDuplicateConfirmedVersion(mismatched_hash),
] ]
); );
@ -589,7 +599,7 @@ mod test {
is_dead is_dead
), ),
vec![ vec![
ResultingStateChange::MarkSlotDuplicate, ResultingStateChange::MarkSlotDuplicate(bank_frozen_hash),
ResultingStateChange::RepairDuplicateConfirmedVersion(correct_hash), ResultingStateChange::RepairDuplicateConfirmedVersion(correct_hash),
] ]
); );
@ -605,7 +615,7 @@ mod test {
is_dead is_dead
), ),
vec![ vec![
ResultingStateChange::MarkSlotDuplicate, ResultingStateChange::MarkSlotDuplicate(bank_frozen_hash),
ResultingStateChange::RepairDuplicateConfirmedVersion(correct_hash), ResultingStateChange::RepairDuplicateConfirmedVersion(correct_hash),
] ]
); );
@ -620,21 +630,22 @@ mod test {
ancestors, ancestors,
descendants, descendants,
slot, slot,
.. bank_forks,
} = setup(); } = setup();
// MarkSlotDuplicate should mark progress map and remove // MarkSlotDuplicate should mark progress map and remove
// the slot from fork choice // the slot from fork choice
let slot_hash = bank_forks.read().unwrap().get(slot).unwrap().hash();
apply_state_changes( apply_state_changes(
slot, slot,
&mut progress, &mut progress,
&mut heaviest_subtree_fork_choice, &mut heaviest_subtree_fork_choice,
&ancestors, &ancestors,
&descendants, &descendants,
vec![ResultingStateChange::MarkSlotDuplicate], vec![ResultingStateChange::MarkSlotDuplicate(slot_hash)],
); );
assert!(!heaviest_subtree_fork_choice assert!(!heaviest_subtree_fork_choice
.is_candidate_slot(slot) .is_candidate_slot(&(slot, slot_hash))
.unwrap()); .unwrap());
for child_slot in descendants for child_slot in descendants
.get(&slot) .get(&slot)
@ -657,7 +668,9 @@ mod test {
&mut heaviest_subtree_fork_choice, &mut heaviest_subtree_fork_choice,
&ancestors, &ancestors,
&descendants, &descendants,
vec![ResultingStateChange::DuplicateConfirmedSlotMatchesCluster], vec![ResultingStateChange::DuplicateConfirmedSlotMatchesCluster(
slot_hash,
)],
); );
for child_slot in descendants for child_slot in descendants
.get(&slot) .get(&slot)
@ -670,7 +683,7 @@ mod test {
.is_none()); .is_none());
} }
assert!(heaviest_subtree_fork_choice assert!(heaviest_subtree_fork_choice
.is_candidate_slot(slot) .is_candidate_slot(&(slot, slot_hash))
.unwrap()); .unwrap());
} }
@ -686,7 +699,11 @@ mod test {
.. ..
} = setup(); } = setup();
assert_eq!(heaviest_subtree_fork_choice.best_overall_slot(), 3); let slot3_hash = bank_forks.read().unwrap().get(3).unwrap().hash();
assert_eq!(
heaviest_subtree_fork_choice.best_overall_slot(),
(3, slot3_hash)
);
let root = 0; let root = 0;
let mut gossip_duplicate_confirmed_slots = GossipDuplicateConfirmedSlots::default(); let mut gossip_duplicate_confirmed_slots = GossipDuplicateConfirmedSlots::default();
@ -705,13 +722,16 @@ mod test {
SlotStateUpdate::DuplicateConfirmed, SlotStateUpdate::DuplicateConfirmed,
); );
assert_eq!(heaviest_subtree_fork_choice.best_overall_slot(), 3); assert_eq!(
heaviest_subtree_fork_choice.best_overall_slot(),
(3, slot3_hash)
);
// Mark 3 as duplicate, should not remove slot 2 from fork choice // Mark 3 as duplicate, should not remove slot 2 from fork choice
check_slot_agrees_with_cluster( check_slot_agrees_with_cluster(
3, 3,
root, root,
Some(bank_forks.read().unwrap().get(3).unwrap().hash()), Some(slot3_hash),
&gossip_duplicate_confirmed_slots, &gossip_duplicate_confirmed_slots,
&ancestors, &ancestors,
&descendants, &descendants,
@ -720,7 +740,10 @@ mod test {
SlotStateUpdate::Duplicate, SlotStateUpdate::Duplicate,
); );
assert_eq!(heaviest_subtree_fork_choice.best_overall_slot(), 2); assert_eq!(
heaviest_subtree_fork_choice.best_overall_slot(),
(2, slot2_hash)
);
} }
#[test] #[test]
@ -735,7 +758,11 @@ mod test {
.. ..
} = setup(); } = setup();
assert_eq!(heaviest_subtree_fork_choice.best_overall_slot(), 3); let slot3_hash = bank_forks.read().unwrap().get(3).unwrap().hash();
assert_eq!(
heaviest_subtree_fork_choice.best_overall_slot(),
(3, slot3_hash)
);
let root = 0; let root = 0;
let mut gossip_duplicate_confirmed_slots = GossipDuplicateConfirmedSlots::default(); let mut gossip_duplicate_confirmed_slots = GossipDuplicateConfirmedSlots::default();
// Mark 2 as duplicate confirmed // Mark 2 as duplicate confirmed
@ -751,10 +778,13 @@ mod test {
SlotStateUpdate::Duplicate, SlotStateUpdate::Duplicate,
); );
assert_eq!(heaviest_subtree_fork_choice.best_overall_slot(), 1); let slot1_hash = bank_forks.read().unwrap().get(1).unwrap().hash();
assert_eq!(
heaviest_subtree_fork_choice.best_overall_slot(),
(1, slot1_hash)
);
// Mark slot 3 as duplicate confirmed, should mark slot 2 as duplicate confirmed as well // Mark slot 3 as duplicate confirmed, should mark slot 2 as duplicate confirmed as well
let slot3_hash = bank_forks.read().unwrap().get(3).unwrap().hash();
gossip_duplicate_confirmed_slots.insert(3, slot3_hash); gossip_duplicate_confirmed_slots.insert(3, slot3_hash);
check_slot_agrees_with_cluster( check_slot_agrees_with_cluster(
3, 3,
@ -768,6 +798,9 @@ mod test {
SlotStateUpdate::DuplicateConfirmed, SlotStateUpdate::DuplicateConfirmed,
); );
assert_eq!(heaviest_subtree_fork_choice.best_overall_slot(), 3); assert_eq!(
heaviest_subtree_fork_choice.best_overall_slot(),
(3, slot3_hash)
);
} }
} }

13
core/src/consensus.rs
View File

@ -197,8 +197,9 @@ impl Tower {
); );
let root = root_bank.slot(); let root = root_bank.slot();
let (best_slot, best_hash) = heaviest_subtree_fork_choice.best_overall_slot();
let heaviest_bank = bank_forks let heaviest_bank = bank_forks
.get(heaviest_subtree_fork_choice.best_overall_slot()) .get_with_checked_hash((best_slot, best_hash))
.expect( .expect(
"The best overall slot must be one of `frozen_banks` which all exist in bank_forks", "The best overall slot must be one of `frozen_banks` which all exist in bank_forks",
) )
@ -436,6 +437,10 @@ impl Tower {
self.last_vote.last_voted_slot() self.last_vote.last_voted_slot()
} }
pub fn last_voted_slot_hash(&self) -> Option<(Slot, Hash)> {
self.last_vote.last_voted_slot_hash()
}
pub fn stray_restored_slot(&self) -> Option<Slot> { pub fn stray_restored_slot(&self) -> Option<Slot> {
self.stray_restored_slot self.stray_restored_slot
} }
@ -1372,8 +1377,10 @@ pub mod test {
} }
} }
new_bank.freeze(); new_bank.freeze();
self.heaviest_subtree_fork_choice self.heaviest_subtree_fork_choice.add_new_leaf_slot(
.add_new_leaf_slot(new_bank.slot(), Some(new_bank.parent_slot())); (new_bank.slot(), new_bank.hash()),
Some((new_bank.parent_slot(), new_bank.parent_hash())),
);
self.bank_forks.write().unwrap().insert(new_bank); self.bank_forks.write().unwrap().insert(new_bank);
walk.forward(); walk.forward();
} }

6
core/src/fork_choice.rs
View File

@ -4,7 +4,6 @@ use crate::{
replay_stage::HeaviestForkFailures, replay_stage::HeaviestForkFailures,
}; };
use solana_runtime::{bank::Bank, bank_forks::BankForks}; use solana_runtime::{bank::Bank, bank_forks::BankForks};
use solana_sdk::clock::Slot;
use std::{ use std::{
collections::{HashMap, HashSet}, collections::{HashMap, HashSet},
sync::{Arc, RwLock}, sync::{Arc, RwLock},
@ -17,6 +16,7 @@ pub(crate) struct SelectVoteAndResetForkResult {
} }
pub(crate) trait ForkChoice { pub(crate) trait ForkChoice {
type ForkChoiceKey;
fn compute_bank_stats( fn compute_bank_stats(
&mut self, &mut self,
bank: &Bank, bank: &Bank,
@ -38,7 +38,7 @@ pub(crate) trait ForkChoice {
bank_forks: &RwLock<BankForks>, bank_forks: &RwLock<BankForks>,
) -> (Arc<Bank>, Option<Arc<Bank>>); ) -> (Arc<Bank>, Option<Arc<Bank>>);
fn mark_fork_invalid_candidate(&mut self, invalid_slot: Slot); fn mark_fork_invalid_candidate(&mut self, invalid_slot: &Self::ForkChoiceKey);
fn mark_fork_valid_candidate(&mut self, valid_slot: Slot); fn mark_fork_valid_candidate(&mut self, valid_slot: &Self::ForkChoiceKey);
} }

2255
core/src/heaviest_subtree_fork_choice.rs
View File

File diff suppressed because it is too large Load Diff

7
core/src/progress_map.rs
View File

@ -257,6 +257,7 @@ pub(crate) struct ForkStats {
pub(crate) is_supermajority_confirmed: bool, pub(crate) is_supermajority_confirmed: bool,
pub(crate) computed: bool, pub(crate) computed: bool,
pub(crate) lockout_intervals: LockoutIntervals, pub(crate) lockout_intervals: LockoutIntervals,
pub(crate) bank_hash: Option<Hash>,
} }
#[derive(Clone, Default)] #[derive(Clone, Default)]
@ -398,6 +399,12 @@ impl ProgressMap {
.map(|fork_progress| fork_progress.is_dead) .map(|fork_progress| fork_progress.is_dead)
} }
pub fn get_hash(&self, slot: Slot) -> Option<Hash> {
self.progress_map
.get(&slot)
.and_then(|fork_progress| fork_progress.fork_stats.bank_hash)
}
pub fn is_propagated(&self, slot: Slot) -> bool { pub fn is_propagated(&self, slot: Slot) -> bool {
let leader_slot_to_check = self.get_latest_leader_slot(slot); let leader_slot_to_check = self.get_latest_leader_slot(slot);

153
core/src/repair_weight.rs
View File

@ -8,6 +8,7 @@ use solana_runtime::{contains::Contains, epoch_stakes::EpochStakes};
use solana_sdk::{ use solana_sdk::{
clock::Slot, clock::Slot,
epoch_schedule::{Epoch, EpochSchedule}, epoch_schedule::{Epoch, EpochSchedule},
hash::Hash,
pubkey::Pubkey, pubkey::Pubkey,
}; };
use std::collections::{BTreeSet, HashMap, HashSet, VecDeque}; use std::collections::{BTreeSet, HashMap, HashSet, VecDeque};
@ -30,7 +31,7 @@ pub struct RepairWeight {
impl RepairWeight { impl RepairWeight {
pub fn new(root: Slot) -> Self { pub fn new(root: Slot) -> Self {
let root_tree = HeaviestSubtreeForkChoice::new(root); let root_tree = HeaviestSubtreeForkChoice::new((root, Hash::default()));
let slot_to_tree: HashMap<Slot, Slot> = vec![(root, root)].into_iter().collect(); let slot_to_tree: HashMap<Slot, Slot> = vec![(root, root)].into_iter().collect();
let trees: HashMap<Slot, HeaviestSubtreeForkChoice> = let trees: HashMap<Slot, HeaviestSubtreeForkChoice> =
vec![(root, root_tree)].into_iter().collect(); vec![(root, root_tree)].into_iter().collect();
@ -102,7 +103,12 @@ impl RepairWeight {
new_ancestors.push_back(slot); new_ancestors.push_back(slot);
if new_ancestors.len() > 1 { if new_ancestors.len() > 1 {
for i in 0..new_ancestors.len() - 1 { for i in 0..new_ancestors.len() - 1 {
tree.add_new_leaf_slot(new_ancestors[i + 1], Some(new_ancestors[i])); // TODO: Repair right now does not distinguish between votes for different
// versions of the same slot.
tree.add_new_leaf_slot(
(new_ancestors[i + 1], Hash::default()),
Some((new_ancestors[i], Hash::default())),
);
self.slot_to_tree.insert(new_ancestors[i + 1], tree_root); self.slot_to_tree.insert(new_ancestors[i + 1], tree_root);
} }
} }
@ -122,7 +128,13 @@ impl RepairWeight {
.get_mut(&tree_root) .get_mut(&tree_root)
.expect("`slot_to_tree` and `self.trees` must be in sync"); .expect("`slot_to_tree` and `self.trees` must be in sync");
let updates: Vec<_> = updates.into_iter().collect(); let updates: Vec<_> = updates.into_iter().collect();
tree.add_votes(&updates, epoch_stakes, epoch_schedule); tree.add_votes(
updates
.iter()
.map(|(pubkey, slot)| (*pubkey, (*slot, Hash::default()))),
epoch_stakes,
epoch_schedule,
);
} }
} }
@ -189,7 +201,9 @@ impl RepairWeight {
.remove(&subtree_root) .remove(&subtree_root)
.expect("Must exist, was found in `self.trees` above"); .expect("Must exist, was found in `self.trees` above");
self.remove_tree_slots( self.remove_tree_slots(
subtree.all_slots_stake_voted_subtree().iter().map(|x| &x.0), subtree
.all_slots_stake_voted_subtree()
.map(|((slot, _), _)| slot),
new_root, new_root,
); );
} }
@ -202,10 +216,16 @@ impl RepairWeight {
// Find all descendants of `self.root` that are not reachable from `new_root`. // Find all descendants of `self.root` that are not reachable from `new_root`.
// These are exactly the unrooted slots, which can be purged and added to // These are exactly the unrooted slots, which can be purged and added to
// `self.unrooted_slots`. // `self.unrooted_slots`.
let unrooted_slots = new_root_tree.subtree_diff(new_root_tree_root, new_root); let unrooted_slots = new_root_tree.subtree_diff(
self.remove_tree_slots(unrooted_slots.iter(), new_root); (new_root_tree_root, Hash::default()),
(new_root, Hash::default()),
);
self.remove_tree_slots(
unrooted_slots.iter().map(|slot_hash| &slot_hash.0),
new_root,
);
new_root_tree.set_root(new_root); new_root_tree.set_root((new_root, Hash::default()));
// Update `self.slot_to_tree` to reflect new root // Update `self.slot_to_tree` to reflect new root
self.rename_tree_root(&new_root_tree, new_root); self.rename_tree_root(&new_root_tree, new_root);
@ -259,7 +279,7 @@ impl RepairWeight {
.map(|(slot, tree)| { .map(|(slot, tree)| {
( (
*slot, *slot,
tree.stake_voted_subtree(*slot) tree.stake_voted_subtree(&(*slot, Hash::default()))
.expect("Tree must have weight at its own root"), .expect("Tree must have weight at its own root"),
) )
}) })
@ -343,7 +363,7 @@ impl RepairWeight {
for ancestor in new_ancestors.iter().skip(num_skip).rev() { for ancestor in new_ancestors.iter().skip(num_skip).rev() {
self.slot_to_tree.insert(*ancestor, orphan_tree_root); self.slot_to_tree.insert(*ancestor, orphan_tree_root);
heaviest_tree.add_root_parent(*ancestor); heaviest_tree.add_root_parent((*ancestor, Hash::default()));
} }
} }
if let Some(parent_tree_root) = parent_tree_root { if let Some(parent_tree_root) = parent_tree_root {
@ -386,8 +406,7 @@ impl RepairWeight {
self.remove_tree_slots( self.remove_tree_slots(
orphan_tree orphan_tree
.all_slots_stake_voted_subtree() .all_slots_stake_voted_subtree()
.iter() .map(|((slot, _), _)| slot),
.map(|x| &x.0),
self.root, self.root,
); );
None None
@ -403,8 +422,10 @@ impl RepairWeight {
// Update `self.slot_to_tree` // Update `self.slot_to_tree`
self.slot_to_tree.insert(new_tree_root, new_tree_root); self.slot_to_tree.insert(new_tree_root, new_tree_root);
self.trees self.trees.insert(
.insert(new_tree_root, HeaviestSubtreeForkChoice::new(new_tree_root)); new_tree_root,
HeaviestSubtreeForkChoice::new((new_tree_root, Hash::default())),
);
} }
fn find_ancestor_subtree_of_slot( fn find_ancestor_subtree_of_slot(
@ -460,13 +481,18 @@ impl RepairWeight {
.get_mut(&root2) .get_mut(&root2)
.expect("tree to be merged into must exist"); .expect("tree to be merged into must exist");
tree2.merge(tree1, merge_leaf, epoch_stakes, epoch_schedule); tree2.merge(
tree1,
&(merge_leaf, Hash::default()),
epoch_stakes,
epoch_schedule,
);
} }
// Update all slots in the `tree1` to point to `root2`, // Update all slots in the `tree1` to point to `root2`,
fn rename_tree_root(&mut self, tree1: &HeaviestSubtreeForkChoice, root2: Slot) { fn rename_tree_root(&mut self, tree1: &HeaviestSubtreeForkChoice, root2: Slot) {
let all_slots = tree1.all_slots_stake_voted_subtree(); let all_slots = tree1.all_slots_stake_voted_subtree();
for (slot, _) in all_slots { for ((slot, _), _) in all_slots {
*self *self
.slot_to_tree .slot_to_tree
.get_mut(&slot) .get_mut(&slot)
@ -560,7 +586,14 @@ mod test {
// repair_weight should contain one subtree 0->1 // repair_weight should contain one subtree 0->1
assert_eq!(repair_weight.trees.len(), 1); assert_eq!(repair_weight.trees.len(), 1);
assert_eq!(repair_weight.trees.get(&0).unwrap().ancestors(1), vec![0]); assert_eq!(
repair_weight
.trees
.get(&0)
.unwrap()
.ancestors((1, Hash::default())),
vec![(0, Hash::default())]
);
for i in &[0, 1] { for i in &[0, 1] {
assert_eq!(*repair_weight.slot_to_tree.get(i).unwrap(), 0); assert_eq!(*repair_weight.slot_to_tree.get(i).unwrap(), 0);
} }
@ -577,11 +610,25 @@ mod test {
); );
assert_eq!(repair_weight.trees.len(), 1); assert_eq!(repair_weight.trees.len(), 1);
assert_eq!( assert_eq!(
repair_weight.trees.get(&0).unwrap().ancestors(4), repair_weight
.trees
.get(&0)
.unwrap()
.ancestors((4, Hash::default()))
.into_iter()
.map(|slot_hash| slot_hash.0)
.collect::<Vec<_>>(),
vec![2, 1, 0] vec![2, 1, 0]
); );
assert_eq!( assert_eq!(
repair_weight.trees.get(&0).unwrap().ancestors(6), repair_weight
.trees
.get(&0)
.unwrap()
.ancestors((6, Hash::default()))
.into_iter()
.map(|slot_hash| slot_hash.0)
.collect::<Vec<_>>(),
vec![5, 3, 1, 0] vec![5, 3, 1, 0]
); );
for slot in 0..=6 { for slot in 0..=6 {
@ -590,7 +637,7 @@ mod test {
.trees .trees
.get(&0) .get(&0)
.unwrap() .unwrap()
.stake_voted_at(slot) .stake_voted_at(&(slot, Hash::default()))
.unwrap(); .unwrap();
if slot == 6 { if slot == 6 {
assert_eq!(stake_voted_at, 3 * stake); assert_eq!(stake_voted_at, 3 * stake);
@ -604,7 +651,7 @@ mod test {
.trees .trees
.get(&0) .get(&0)
.unwrap() .unwrap()
.stake_voted_subtree(*slot) .stake_voted_subtree(&(*slot, Hash::default()))
.unwrap(); .unwrap();
assert_eq!(stake_voted_subtree, 3 * stake); assert_eq!(stake_voted_subtree, 3 * stake);
} }
@ -613,7 +660,7 @@ mod test {
.trees .trees
.get(&0) .get(&0)
.unwrap() .unwrap()
.stake_voted_subtree(*slot) .stake_voted_subtree(&(*slot, Hash::default()))
.unwrap(); .unwrap();
assert_eq!(stake_voted_subtree, 0); assert_eq!(stake_voted_subtree, 0);
} }
@ -637,8 +684,20 @@ mod test {
// Should contain two trees, one for main fork, one for the orphan // Should contain two trees, one for main fork, one for the orphan
// branch // branch
assert_eq!(repair_weight.trees.len(), 2); assert_eq!(repair_weight.trees.len(), 2);
assert_eq!(repair_weight.trees.get(&0).unwrap().ancestors(1), vec![0]); assert_eq!(
assert!(repair_weight.trees.get(&8).unwrap().ancestors(8).is_empty()); repair_weight
.trees
.get(&0)
.unwrap()
.ancestors((1, Hash::default())),
vec![(0, Hash::default())]
);
assert!(repair_weight
.trees
.get(&8)
.unwrap()
.ancestors((8, Hash::default()))
.is_empty());
let votes = vec![(1, vote_pubkeys.clone()), (10, vote_pubkeys.clone())]; let votes = vec![(1, vote_pubkeys.clone()), (10, vote_pubkeys.clone())];
let mut repair_weight = RepairWeight::new(0); let mut repair_weight = RepairWeight::new(0);
@ -652,8 +711,22 @@ mod test {
// Should contain two trees, one for main fork, one for the orphan // Should contain two trees, one for main fork, one for the orphan
// branch // branch
assert_eq!(repair_weight.trees.len(), 2); assert_eq!(repair_weight.trees.len(), 2);
assert_eq!(repair_weight.trees.get(&0).unwrap().ancestors(1), vec![0]); assert_eq!(
assert_eq!(repair_weight.trees.get(&8).unwrap().ancestors(10), vec![8]); repair_weight
.trees
.get(&0)
.unwrap()
.ancestors((1, Hash::default())),
vec![(0, Hash::default())]
);
assert_eq!(
repair_weight
.trees
.get(&8)
.unwrap()
.ancestors((10, Hash::default())),
vec![(8, Hash::default())]
);
// Connect orphan back to main fork // Connect orphan back to main fork
blockstore.add_tree(tr(6) / (tr(8)), true, true, 2, Hash::default()); blockstore.add_tree(tr(6) / (tr(8)), true, true, 2, Hash::default());
@ -672,7 +745,14 @@ mod test {
bank.epoch_schedule(), bank.epoch_schedule(),
); );
assert_eq!( assert_eq!(
repair_weight.trees.get(&8).unwrap().ancestors(11), repair_weight
.trees
.get(&8)
.unwrap()
.ancestors((11, Hash::default()))
.into_iter()
.map(|slot_hash| slot_hash.0)
.collect::<Vec<_>>(),
vec![10, 8] vec![10, 8]
); );
@ -784,13 +864,13 @@ mod test {
.trees .trees
.get(&8) .get(&8)
.unwrap() .unwrap()
.stake_voted_subtree(8) .stake_voted_subtree(&(8, Hash::default()))
.unwrap(), .unwrap(),
repair_weight repair_weight
.trees .trees
.get(&20) .get(&20)
.unwrap() .unwrap()
.stake_voted_subtree(20) .stake_voted_subtree(&(20, Hash::default()))
.unwrap() .unwrap()
); );
assert_eq!(repairs.len(), 1); assert_eq!(repairs.len(), 1);
@ -929,11 +1009,11 @@ mod test {
assert_eq!(*repair_weight.slot_to_tree.get(&2).unwrap(), 1); assert_eq!(*repair_weight.slot_to_tree.get(&2).unwrap(), 1);
// Trees tracked should be updated // Trees tracked should be updated
assert_eq!(repair_weight.trees.get(&1).unwrap().root(), 1); assert_eq!(repair_weight.trees.get(&1).unwrap().root().0, 1);
// Orphan slots should not be changed // Orphan slots should not be changed
for orphan in &[8, 20] { for orphan in &[8, 20] {
assert_eq!(repair_weight.trees.get(orphan).unwrap().root(), *orphan); assert_eq!(repair_weight.trees.get(orphan).unwrap().root().0, *orphan);
assert_eq!(repair_weight.slot_to_tree.get(orphan).unwrap(), orphan); assert_eq!(repair_weight.slot_to_tree.get(orphan).unwrap(), orphan);
} }
} }
@ -957,7 +1037,7 @@ mod test {
// Orphan slots should not be changed // Orphan slots should not be changed
for orphan in &[8, 20] { for orphan in &[8, 20] {
assert_eq!(repair_weight.trees.get(orphan).unwrap().root(), *orphan); assert_eq!(repair_weight.trees.get(orphan).unwrap().root().0, *orphan);
assert_eq!(repair_weight.slot_to_tree.get(orphan).unwrap(), orphan); assert_eq!(repair_weight.slot_to_tree.get(orphan).unwrap(), orphan);
} }
} }
@ -979,7 +1059,7 @@ mod test {
assert!(!repair_weight.slot_to_tree.contains_key(&8)); assert!(!repair_weight.slot_to_tree.contains_key(&8));
// Other higher orphan branch rooted at slot `20` remains unchanged // Other higher orphan branch rooted at slot `20` remains unchanged
assert_eq!(repair_weight.trees.get(&20).unwrap().root(), 20); assert_eq!(repair_weight.trees.get(&20).unwrap().root().0, 20);
assert_eq!(*repair_weight.slot_to_tree.get(&20).unwrap(), 20); assert_eq!(*repair_weight.slot_to_tree.get(&20).unwrap(), 20);
} }
@ -1020,7 +1100,7 @@ mod test {
// Orphan 20 should still exist // Orphan 20 should still exist
assert_eq!(repair_weight.trees.len(), 2); assert_eq!(repair_weight.trees.len(), 2);
assert_eq!(repair_weight.trees.get(&20).unwrap().root(), 20); assert_eq!(repair_weight.trees.get(&20).unwrap().root().0, 20);
assert_eq!(*repair_weight.slot_to_tree.get(&20).unwrap(), 20); assert_eq!(*repair_weight.slot_to_tree.get(&20).unwrap(), 20);
// Now set root at a slot 30 that doesnt exist in `repair_weight`, but is // Now set root at a slot 30 that doesnt exist in `repair_weight`, but is
@ -1191,7 +1271,7 @@ mod test {
// Check orphans are present // Check orphans are present
for orphan in &[8, 20] { for orphan in &[8, 20] {
assert_eq!(repair_weight.trees.get(orphan).unwrap().root(), *orphan); assert_eq!(repair_weight.trees.get(orphan).unwrap().root().0, *orphan);
assert_eq!(repair_weight.slot_to_tree.get(orphan).unwrap(), orphan); assert_eq!(repair_weight.slot_to_tree.get(orphan).unwrap(), orphan);
} }
(blockstore, bank, repair_weight) (blockstore, bank, repair_weight)
@ -1208,7 +1288,10 @@ mod test {
assert!(!repair_weight.unrooted_slots.contains(&old_root)); assert!(!repair_weight.unrooted_slots.contains(&old_root));
// Validate new root // Validate new root
assert_eq!(repair_weight.trees.get(&new_root).unwrap().root(), new_root); assert_eq!(
repair_weight.trees.get(&new_root).unwrap().root().0,
new_root
);
assert_eq!( assert_eq!(
*repair_weight.slot_to_tree.get(&new_root).unwrap(), *repair_weight.slot_to_tree.get(&new_root).unwrap(),
new_root new_root

28
core/src/repair_weighted_traversal.rs
View File

@ -4,7 +4,7 @@ use crate::{
}; };
use solana_ledger::blockstore::Blockstore; use solana_ledger::blockstore::Blockstore;
use solana_runtime::contains::Contains; use solana_runtime::contains::Contains;
use solana_sdk::clock::Slot; use solana_sdk::{clock::Slot, hash::Hash};
use std::collections::{HashMap, HashSet}; use std::collections::{HashMap, HashSet};
#[derive(Debug, PartialEq)] #[derive(Debug, PartialEq)]
@ -32,7 +32,7 @@ impl<'a> RepairWeightTraversal<'a> {
pub fn new(tree: &'a HeaviestSubtreeForkChoice) -> Self { pub fn new(tree: &'a HeaviestSubtreeForkChoice) -> Self {
Self { Self {
tree, tree,
pending: vec![Visit::Unvisited(tree.root())], pending: vec![Visit::Unvisited(tree.root().0)],
} }
} }
} }
@ -48,16 +48,20 @@ impl<'a> Iterator for RepairWeightTraversal<'a> {
self.pending.push(Visit::Visited(slot)); self.pending.push(Visit::Visited(slot));
let mut children: Vec<_> = self let mut children: Vec<_> = self
.tree .tree
.children(slot) .children(&(slot, Hash::default()))
.unwrap() .unwrap()
.iter() .iter()
.map(|child_slot| Visit::Unvisited(*child_slot)) .map(|(child_slot, _)| Visit::Unvisited(*child_slot))
.collect(); .collect();
// Sort children by weight to prioritize visiting the heaviest // Sort children by weight to prioritize visiting the heaviest
// ones first // ones first
children children.sort_by(|slot1, slot2| {
.sort_by(|slot1, slot2| self.tree.max_by_weight(slot1.slot(), slot2.slot())); self.tree.max_by_weight(
(slot1.slot(), Hash::default()),
(slot2.slot(), Hash::default()),
)
});
self.pending.extend(children); self.pending.extend(children);
} }
next next
@ -87,6 +91,9 @@ pub fn get_best_repair_shreds<'a>(
.entry(next.slot()) .entry(next.slot())
.or_insert_with(|| blockstore.meta(next.slot()).unwrap()); .or_insert_with(|| blockstore.meta(next.slot()).unwrap());
// May not exist if blockstore purged the SlotMeta due to something
// like duplicate slots. TODO: Account for duplicate slot may be in orphans, especially
// if earlier duplicate was already removed
if let Some(slot_meta) = slot_meta { if let Some(slot_meta) = slot_meta {
match next { match next {
Visit::Unvisited(slot) => { Visit::Unvisited(slot) => {
@ -137,7 +144,7 @@ pub mod test {
#[test] #[test]
fn test_weighted_repair_traversal_single() { fn test_weighted_repair_traversal_single() {
let heaviest_subtree_fork_choice = HeaviestSubtreeForkChoice::new(42); let heaviest_subtree_fork_choice = HeaviestSubtreeForkChoice::new((42, Hash::default()));
let weighted_traversal = RepairWeightTraversal::new(&heaviest_subtree_fork_choice); let weighted_traversal = RepairWeightTraversal::new(&heaviest_subtree_fork_choice);
let steps: Vec<_> = weighted_traversal.collect(); let steps: Vec<_> = weighted_traversal.collect();
assert_eq!(steps, vec![Visit::Unvisited(42), Visit::Visited(42)]); assert_eq!(steps, vec![Visit::Unvisited(42), Visit::Visited(42)]);
@ -174,7 +181,7 @@ pub mod test {
// Add a vote to branch with slot 5, // Add a vote to branch with slot 5,
// should prioritize that branch // should prioritize that branch
heaviest_subtree_fork_choice.add_votes( heaviest_subtree_fork_choice.add_votes(
&[(vote_pubkeys[0], 5)], [(vote_pubkeys[0], (5, Hash::default()))].iter(),
bank.epoch_stakes_map(), bank.epoch_stakes_map(),
bank.epoch_schedule(), bank.epoch_schedule(),
); );
@ -227,8 +234,8 @@ pub mod test {
// Add some leaves to blockstore, attached to the current best leaf, should prioritize // Add some leaves to blockstore, attached to the current best leaf, should prioritize
// repairing those new leaves before trying other branches // repairing those new leaves before trying other branches
repairs = vec![]; repairs = vec![];
let best_overall_slot = heaviest_subtree_fork_choice.best_overall_slot(); let best_overall_slot = heaviest_subtree_fork_choice.best_overall_slot().0;
assert_eq!(heaviest_subtree_fork_choice.best_overall_slot(), 4); assert_eq!(best_overall_slot, 4);
blockstore.add_tree( blockstore.add_tree(
tr(best_overall_slot) / (tr(6) / tr(7)), tr(best_overall_slot) / (tr(6) / tr(7)),
true, true,
@ -406,6 +413,7 @@ pub mod test {
slot 4 | slot 4 |
slot 5 slot 5
*/ */
let forks = tr(0) / (tr(1) / (tr(2) / (tr(4))) / (tr(3) / (tr(5)))); let forks = tr(0) / (tr(1) / (tr(2) / (tr(4))) / (tr(3) / (tr(5))));
let ledger_path = get_tmp_ledger_path!(); let ledger_path = get_tmp_ledger_path!();
let blockstore = Blockstore::open(&ledger_path).unwrap(); let blockstore = Blockstore::open(&ledger_path).unwrap();

65
core/src/replay_stage.rs
View File

@ -753,8 +753,10 @@ impl ReplayStage {
); );
} }
let root = root_bank.slot(); let root = root_bank.slot();
let heaviest_subtree_fork_choice = let heaviest_subtree_fork_choice = HeaviestSubtreeForkChoice::new_from_frozen_banks(
HeaviestSubtreeForkChoice::new_from_frozen_banks(root, &frozen_banks); (root, root_bank.hash()),
&frozen_banks,
);
(progress, heaviest_subtree_fork_choice) (progress, heaviest_subtree_fork_choice)
} }
@ -1609,8 +1611,12 @@ impl ReplayStage {
transaction_status_sender.send_transaction_status_freeze_message(&bank); transaction_status_sender.send_transaction_status_freeze_message(&bank);
} }
bank.freeze(); bank.freeze();
heaviest_subtree_fork_choice let bank_hash = bank.hash();
.add_new_leaf_slot(bank.slot(), Some(bank.parent_slot())); assert_ne!(bank_hash, Hash::default());
heaviest_subtree_fork_choice.add_new_leaf_slot(
(bank.slot(), bank.hash()),
Some((bank.parent_slot(), bank.parent_hash())),
);
check_slot_agrees_with_cluster( check_slot_agrees_with_cluster(
bank.slot(), bank.slot(),
bank_forks.read().unwrap().root(), bank_forks.read().unwrap().root(),
@ -1652,7 +1658,7 @@ impl ReplayStage {
vote_tracker: &VoteTracker, vote_tracker: &VoteTracker,
cluster_slots: &ClusterSlots, cluster_slots: &ClusterSlots,
bank_forks: &RwLock<BankForks>, bank_forks: &RwLock<BankForks>,
heaviest_subtree_fork_choice: &mut dyn ForkChoice, heaviest_subtree_fork_choice: &mut HeaviestSubtreeForkChoice,
) -> Vec<Slot> { ) -> Vec<Slot> {
frozen_banks.sort_by_key(|bank| bank.slot()); frozen_banks.sort_by_key(|bank| bank.slot());
let mut new_stats = vec![]; let mut new_stats = vec![];
@ -1694,6 +1700,7 @@ impl ReplayStage {
stats.voted_stakes = voted_stakes; stats.voted_stakes = voted_stakes;
stats.lockout_intervals = lockout_intervals; stats.lockout_intervals = lockout_intervals;
stats.block_height = bank.block_height(); stats.block_height = bank.block_height();
stats.bank_hash = Some(bank.hash());
stats.computed = true; stats.computed = true;
new_stats.push(bank_slot); new_stats.push(bank_slot);
datapoint_info!( datapoint_info!(
@ -2202,9 +2209,9 @@ impl ReplayStage {
} }
} }
progress.handle_new_root(&r_bank_forks); progress.handle_new_root(&r_bank_forks);
heaviest_subtree_fork_choice.set_root(new_root); heaviest_subtree_fork_choice.set_root((new_root, r_bank_forks.root_bank().hash()));
let mut slots_ge_root = gossip_duplicate_confirmed_slots.split_off(&new_root); let mut slots_ge_root = gossip_duplicate_confirmed_slots.split_off(&new_root);
// gossip_duplicate_confirmed_slots now only contains entries >= `new_root` // gossip_confirmed_slots now only contains entries >= `new_root`
std::mem::swap(gossip_duplicate_confirmed_slots, &mut slots_ge_root); std::mem::swap(gossip_duplicate_confirmed_slots, &mut slots_ge_root);
let mut slots_ge_root = gossip_verified_vote_hashes.split_off(&new_root); let mut slots_ge_root = gossip_verified_vote_hashes.split_off(&new_root);
@ -2598,14 +2605,19 @@ pub(crate) mod tests {
let genesis_config = create_genesis_config(10_000).genesis_config; let genesis_config = create_genesis_config(10_000).genesis_config;
let bank0 = Bank::new(&genesis_config); let bank0 = Bank::new(&genesis_config);
let bank_forks = Arc::new(RwLock::new(BankForks::new(bank0))); let bank_forks = Arc::new(RwLock::new(BankForks::new(bank0)));
let root = 3; let root = 3;
let mut heaviest_subtree_fork_choice = HeaviestSubtreeForkChoice::new(root);
let root_bank = Bank::new_from_parent( let root_bank = Bank::new_from_parent(
bank_forks.read().unwrap().get(0).unwrap(), bank_forks.read().unwrap().get(0).unwrap(),
&Pubkey::default(), &Pubkey::default(),
root, root,
); );
root_bank.freeze();
let root_hash = root_bank.hash();
bank_forks.write().unwrap().insert(root_bank); bank_forks.write().unwrap().insert(root_bank);
let mut heaviest_subtree_fork_choice = HeaviestSubtreeForkChoice::new((root, root_hash));
let mut progress = ProgressMap::default(); let mut progress = ProgressMap::default();
for i in 0..=root { for i in 0..=root {
progress.insert( progress.insert(
@ -2680,8 +2692,10 @@ pub(crate) mod tests {
&Pubkey::default(), &Pubkey::default(),
root, root,
); );
root_bank.freeze();
let root_hash = root_bank.hash();
bank_forks.write().unwrap().insert(root_bank); bank_forks.write().unwrap().insert(root_bank);
let mut heaviest_subtree_fork_choice = HeaviestSubtreeForkChoice::new(root); let mut heaviest_subtree_fork_choice = HeaviestSubtreeForkChoice::new((root, root_hash));
let mut progress = ProgressMap::default(); let mut progress = ProgressMap::default();
for i in 0..=root { for i in 0..=root {
progress.insert( progress.insert(
@ -2975,7 +2989,7 @@ pub(crate) mod tests {
&HashMap::new(), &HashMap::new(),
&HashMap::new(), &HashMap::new(),
&mut progress, &mut progress,
&mut HeaviestSubtreeForkChoice::new(0), &mut HeaviestSubtreeForkChoice::new((0, Hash::default())),
); );
} }
@ -3376,8 +3390,7 @@ pub(crate) mod tests {
// Create the tree of banks in a BankForks object // Create the tree of banks in a BankForks object
let forks = tr(0) / (tr(1)) / (tr(2)); let forks = tr(0) / (tr(1)) / (tr(2));
vote_simulator.fill_bank_forks(forks.clone(), &HashMap::new()); vote_simulator.fill_bank_forks(forks, &HashMap::new());
let mut heaviest_subtree_fork_choice = HeaviestSubtreeForkChoice::new_from_tree(forks);
let mut frozen_banks: Vec<_> = vote_simulator let mut frozen_banks: Vec<_> = vote_simulator
.bank_forks .bank_forks
.read() .read()
@ -3386,6 +3399,7 @@ pub(crate) mod tests {
.values() .values()
.cloned() .cloned()
.collect(); .collect();
let mut heaviest_subtree_fork_choice = &mut vote_simulator.heaviest_subtree_fork_choice;
let ancestors = vote_simulator.bank_forks.read().unwrap().ancestors(); let ancestors = vote_simulator.bank_forks.read().unwrap().ancestors();
ReplayStage::compute_bank_stats( ReplayStage::compute_bank_stats(
@ -3400,9 +3414,27 @@ pub(crate) mod tests {
&mut heaviest_subtree_fork_choice, &mut heaviest_subtree_fork_choice,
); );
let bank1 = vote_simulator
.bank_forks
.read()
.unwrap()
.get(1)
.unwrap()
.clone();
let bank2 = vote_simulator
.bank_forks
.read()
.unwrap()
.get(2)
.unwrap()
.clone();
assert_eq!( assert_eq!(
heaviest_subtree_fork_choice.stake_voted_subtree(1).unwrap(), heaviest_subtree_fork_choice
heaviest_subtree_fork_choice.stake_voted_subtree(2).unwrap() .stake_voted_subtree(&(1, bank1.hash()))
.unwrap(),
heaviest_subtree_fork_choice
.stake_voted_subtree(&(2, bank2.hash()))
.unwrap()
); );
let (heaviest_bank, _) = heaviest_subtree_fork_choice.select_forks( let (heaviest_bank, _) = heaviest_subtree_fork_choice.select_forks(
@ -3480,8 +3512,9 @@ pub(crate) mod tests {
assert_eq!( assert_eq!(
vote_simulator vote_simulator
.heaviest_subtree_fork_choice .heaviest_subtree_fork_choice
.best_slot(bank.slot()) .best_slot(&(bank.slot(), bank.hash()))
.unwrap(), .unwrap()
.0,
3 3
); );
} }

26
core/src/tree_diff.rs
View File

@ -1,30 +1,30 @@
use solana_sdk::clock::Slot; use std::{collections::HashSet, hash::Hash};
use std::collections::HashSet;
pub trait TreeDiff { pub trait TreeDiff {
fn children(&self, slot: Slot) -> Option<&[Slot]>; type TreeKey: Hash + PartialEq + Eq + Copy;
fn children(&self, key: &Self::TreeKey) -> Option<&[Self::TreeKey]>;
fn contains_slot(&self, slot: Slot) -> bool; fn contains_slot(&self, slot: &Self::TreeKey) -> bool;
// Find all nodes reachable from `root1`, excluding subtree at `root2` // Find all nodes reachable from `root1`, excluding subtree at `root2`
fn subtree_diff(&self, root1: Slot, root2: Slot) -> HashSet<Slot> { fn subtree_diff(&self, root1: Self::TreeKey, root2: Self::TreeKey) -> HashSet<Self::TreeKey> {
if !self.contains_slot(root1) { if !self.contains_slot(&root1) {
return HashSet::new(); return HashSet::new();
} }
let mut pending_slots = vec![root1]; let mut pending_keys = vec![root1];
let mut reachable_set = HashSet::new(); let mut reachable_set = HashSet::new();
while !pending_slots.is_empty() { while !pending_keys.is_empty() {
let current_slot = pending_slots.pop().unwrap(); let current_key = pending_keys.pop().unwrap();
if current_slot == root2 { if current_key == root2 {
continue; continue;
} }
reachable_set.insert(current_slot);
for child in self for child in self
.children(current_slot) .children(&current_key)
.expect("slot was discovered earlier, must exist") .expect("slot was discovered earlier, must exist")
{ {
pending_slots.push(*child); pending_keys.push(*child);
} }
reachable_set.insert(current_key);
} }
reachable_set reachable_set

4
programs/vote/src/vote_state/mod.rs
View File

@ -59,6 +59,10 @@ impl Vote {
pub fn last_voted_slot(&self) -> Option<Slot> { pub fn last_voted_slot(&self) -> Option<Slot> {
self.slots.last().copied() self.slots.last().copied()
} }
pub fn last_voted_slot_hash(&self) -> Option<(Slot, Hash)> {
self.slots.last().copied().map(|slot| (slot, self.hash))
}
} }
#[derive(Serialize, Default, Deserialize, Debug, PartialEq, Eq, Clone, AbiExample)] #[derive(Serialize, Default, Deserialize, Debug, PartialEq, Eq, Clone, AbiExample)]

4
runtime/src/bank.rs
View File

@ -2127,6 +2127,10 @@ impl Bank {
self.parent_slot self.parent_slot
} }
pub fn parent_hash(&self) -> Hash {
self.parent_hash
}
fn process_genesis_config(&mut self, genesis_config: &GenesisConfig) { fn process_genesis_config(&mut self, genesis_config: &GenesisConfig) {
// Bootstrap validator collects fees until `new_from_parent` is called. // Bootstrap validator collects fees until `new_from_parent` is called.
self.fee_rate_governor = genesis_config.fee_rate_governor.clone(); self.fee_rate_governor = genesis_config.fee_rate_governor.clone();

13
runtime/src/bank_forks.rs
View File

@ -6,7 +6,7 @@ use crate::{
}; };
use log::*; use log::*;
use solana_metrics::inc_new_counter_info; use solana_metrics::inc_new_counter_info;
use solana_sdk::{clock::Slot, timing}; use solana_sdk::{clock::Slot, hash::Hash, timing};
use std::{ use std::{
collections::{hash_map::Entry, HashMap, HashSet}, collections::{hash_map::Entry, HashMap, HashSet},
ops::Index, ops::Index,
@ -106,6 +106,17 @@ impl BankForks {
self.banks.get(&bank_slot) self.banks.get(&bank_slot)
} }
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 {
assert_eq!(bank.hash(), expected_hash);
}
maybe_bank
}
pub fn root_bank(&self) -> Arc<Bank> { pub fn root_bank(&self) -> Arc<Bank> {
self[self.root()].clone() self[self.root()].clone()
} }