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

root -> alive_root (#24062)

This commit is contained in:
Jeff Washington (jwash) 2022-04-02 12:00:52 -05:00 committed by GitHub
parent ffa4cafe1c
commit 3ca4fffa78
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 65 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
runtime/src/accounts_db.rs
View File

@ -2950,8 +2950,8 @@ impl AccountsDb {
self.storage.all_slots() self.storage.all_slots()
} }
fn all_root_slots_in_index(&self) -> Vec<Slot> { fn all_alive_roots_in_index(&self) -> Vec<Slot> {
self.accounts_index.all_roots() self.accounts_index.all_alive_roots()
} }
/// Given the input `ShrinkCandidates`, this function sorts the stores by their alive ratio /// Given the input `ShrinkCandidates`, this function sorts the stores by their alive ratio
@ -4296,7 +4296,7 @@ impl AccountsDb {
// Also note roots are never removed via `remove_unrooted_slot()`, so // Also note roots are never removed via `remove_unrooted_slot()`, so
// it's safe to filter them out here as they won't need deletion from // it's safe to filter them out here as they won't need deletion from
// self.accounts_index.removed_bank_ids in `purge_slots_from_cache_and_store()`. // self.accounts_index.removed_bank_ids in `purge_slots_from_cache_and_store()`.
.filter(|slot| !self.accounts_index.is_root(**slot)); .filter(|slot| !self.accounts_index.is_alive_root(**slot));
safety_checks_elapsed.stop(); safety_checks_elapsed.stop();
self.external_purge_slots_stats self.external_purge_slots_stats
.safety_checks_elapsed .safety_checks_elapsed
@ -5437,7 +5437,7 @@ impl AccountsDb {
if let Some(slot_cache) = self.accounts_cache.slot_cache(slot) { if let Some(slot_cache) = self.accounts_cache.slot_cache(slot) {
if valid_slot if valid_slot
|| ancestors.contains_key(&slot) || ancestors.contains_key(&slot)
|| self.accounts_index.is_root(slot) || self.accounts_index.is_alive_root(slot)
{ {
let keys = slot_cache.get_all_pubkeys(); let keys = slot_cache.get_all_pubkeys();
for key in keys { for key in keys {
@ -5510,7 +5510,7 @@ impl AccountsDb {
collect_time.stop(); collect_time.stop();
let mut sort_time = Measure::start("sort_storages"); let mut sort_time = Measure::start("sort_storages");
let min_root = self.accounts_index.min_root(); let min_root = self.accounts_index.min_alive_root();
let storages = SortedStorages::new_with_slots( let storages = SortedStorages::new_with_slots(
combined_maps.iter().zip(slots.into_iter()), combined_maps.iter().zip(slots.into_iter()),
min_root, min_root,
@ -6630,7 +6630,7 @@ impl AccountsDb {
if *slot <= snapshot_slot if *slot <= snapshot_slot
&& snapshot_base_slot && snapshot_base_slot
.map_or(true, |snapshot_base_slot| *slot > snapshot_base_slot) .map_or(true, |snapshot_base_slot| *slot > snapshot_base_slot)
&& (self.accounts_index.is_root(*slot) && (self.accounts_index.is_alive_root(*slot)
|| ancestors || ancestors
.map(|ancestors| ancestors.contains_key(slot)) .map(|ancestors| ancestors.contains_key(slot))
.unwrap_or_default()) .unwrap_or_default())
@ -7274,10 +7274,10 @@ impl AccountsDb {
} }
fn print_index(&self, label: &str) { fn print_index(&self, label: &str) {
let mut roots: Vec<_> = self.accounts_index.all_roots(); let mut alive_roots: Vec<_> = self.accounts_index.all_alive_roots();
#[allow(clippy::stable_sort_primitive)] #[allow(clippy::stable_sort_primitive)]
roots.sort(); alive_roots.sort();
info!("{}: accounts_index roots: {:?}", label, roots,); info!("{}: accounts_index alive_roots: {:?}", label, alive_roots,);
let full_pubkey_range = Pubkey::new(&[0; 32])..=Pubkey::new(&[0xff; 32]); let full_pubkey_range = Pubkey::new(&[0; 32])..=Pubkey::new(&[0xff; 32]);
self.accounts_index.account_maps.iter().for_each(|map| { self.accounts_index.account_maps.iter().for_each(|map| {
@ -7449,7 +7449,7 @@ impl AccountsDb {
let mut shrunken_account_total = 0; let mut shrunken_account_total = 0;
let mut shrunk_slot_count = 0; let mut shrunk_slot_count = 0;
let start = Instant::now(); let start = Instant::now();
let num_roots = self.accounts_index.num_roots(); let num_roots = self.accounts_index.num_alive_roots();
loop { loop {
if let Some(slot) = self.do_next_shrink_slot_v1(candidates) { if let Some(slot) = self.do_next_shrink_slot_v1(candidates) {
shrunken_account_total += self.do_shrink_stale_slot_v1(slot); shrunken_account_total += self.do_shrink_stale_slot_v1(slot);
@ -7480,7 +7480,7 @@ impl AccountsDb {
if next.is_some() { if next.is_some() {
next next
} else { } else {
let mut new_all_slots = self.all_root_slots_in_index(); let mut new_all_slots = self.all_alive_roots_in_index();
let next = new_all_slots.pop(); let next = new_all_slots.pop();
// refresh candidates for later calls! // refresh candidates for later calls!
**candidates = new_all_slots; **candidates = new_all_slots;

94
runtime/src/accounts_index.rs
View File

@ -400,11 +400,11 @@ impl<T: IndexValue> PreAllocatedAccountMapEntry<T> {
#[derive(Debug)] #[derive(Debug)]
pub struct RootsTracker { pub struct RootsTracker {
/// current set of roots active in approx. the current epoch /// current set of roots alive in approx. the current epoch
pub(crate) roots: RollingBitField, pub(crate) alive_roots: RollingBitField,
/// Set of roots approx. within the current epoch that are roots now or were roots at one point in time. /// Set of roots approx. within the current epoch that are roots now or were roots at one point in time.
/// A root could remain here if all entries in the append vec at that root are cleaned/shrunk and there are no /// A root could remain here if all entries in the append vec at that root are cleaned/shrunk and there are no
/// more entries that slot. 'roots' will no longer contain such roots. /// more entries that slot. 'alive_roots' will no longer contain such roots.
pub(crate) roots_original: RollingBitField, pub(crate) roots_original: RollingBitField,
uncleaned_roots: HashSet<Slot>, uncleaned_roots: HashSet<Slot>,
previous_uncleaned_roots: HashSet<Slot>, previous_uncleaned_roots: HashSet<Slot>,
@ -422,15 +422,15 @@ impl Default for RootsTracker {
impl RootsTracker { impl RootsTracker {
pub fn new(max_width: u64) -> Self { pub fn new(max_width: u64) -> Self {
Self { Self {
roots: RollingBitField::new(max_width), alive_roots: RollingBitField::new(max_width),
roots_original: RollingBitField::new(max_width), roots_original: RollingBitField::new(max_width),
uncleaned_roots: HashSet::new(), uncleaned_roots: HashSet::new(),
previous_uncleaned_roots: HashSet::new(), previous_uncleaned_roots: HashSet::new(),
} }
} }
pub fn min_root(&self) -> Option<Slot> { pub fn min_alive_root(&self) -> Option<Slot> {
self.roots.min() self.alive_roots.min()
} }
} }
@ -1157,7 +1157,7 @@ impl<T: IndexValue> AccountsIndex<T> {
pub fn get_rooted_entries(&self, slice: SlotSlice<T>, max: Option<Slot>) -> SlotList<T> { pub fn get_rooted_entries(&self, slice: SlotSlice<T>, max: Option<Slot>) -> SlotList<T> {
let max = max.unwrap_or(Slot::MAX); let max = max.unwrap_or(Slot::MAX);
let lock = &self.roots_tracker.read().unwrap().roots; let lock = &self.roots_tracker.read().unwrap().alive_roots;
slice slice
.iter() .iter()
.filter(|(slot, _)| *slot <= max && lock.contains(slot)) .filter(|(slot, _)| *slot <= max && lock.contains(slot))
@ -1240,7 +1240,7 @@ impl<T: IndexValue> AccountsIndex<T> {
Some(inner) => inner, Some(inner) => inner,
None => self.roots_tracker.read().unwrap(), None => self.roots_tracker.read().unwrap(),
}; };
if lock.roots.contains(slot) { if lock.alive_roots.contains(slot) {
rv = Some(i); rv = Some(i);
current_max = *slot; current_max = *slot;
} }
@ -1341,7 +1341,7 @@ impl<T: IndexValue> AccountsIndex<T> {
// Get the maximum root <= `max_allowed_root` from the given `slice` // Get the maximum root <= `max_allowed_root` from the given `slice`
fn get_newest_root_in_slot_list( fn get_newest_root_in_slot_list(
roots: &RollingBitField, alive_roots: &RollingBitField,
slice: SlotSlice<T>, slice: SlotSlice<T>,
max_allowed_root: Option<Slot>, max_allowed_root: Option<Slot>,
) -> Slot { ) -> Slot {
@ -1352,7 +1352,7 @@ impl<T: IndexValue> AccountsIndex<T> {
continue; continue;
} }
} }
if *f > max_root && roots.contains(f) { if *f > max_root && alive_roots.contains(f) {
max_root = *f; max_root = *f;
} }
} }
@ -1609,9 +1609,13 @@ impl<T: IndexValue> AccountsIndex<T> {
max_clean_root: Option<Slot>, max_clean_root: Option<Slot>,
) { ) {
let roots_tracker = &self.roots_tracker.read().unwrap(); let roots_tracker = &self.roots_tracker.read().unwrap();
let newest_root_in_slot_list = let newest_root_in_slot_list = Self::get_newest_root_in_slot_list(
Self::get_newest_root_in_slot_list(&roots_tracker.roots, slot_list, max_clean_root); &roots_tracker.alive_roots,
let max_clean_root = max_clean_root.unwrap_or_else(|| roots_tracker.roots.max_inclusive()); slot_list,
max_clean_root,
);
let max_clean_root =
max_clean_root.unwrap_or_else(|| roots_tracker.alive_roots.max_inclusive());
slot_list.retain(|(slot, value)| { slot_list.retain(|(slot, value)| {
let should_purge = let should_purge =
@ -1671,7 +1675,7 @@ impl<T: IndexValue> AccountsIndex<T> {
let roots_tracker = self.roots_tracker.read().unwrap(); let roots_tracker = self.roots_tracker.read().unwrap();
slots slots
.filter_map(|s| { .filter_map(|s| {
if roots_tracker.roots.contains(s) { if roots_tracker.alive_roots.contains(s) {
Some(*s) Some(*s)
} else { } else {
None None
@ -1680,16 +1684,20 @@ impl<T: IndexValue> AccountsIndex<T> {
.collect() .collect()
} }
pub fn is_root(&self, slot: Slot) -> bool { pub fn is_alive_root(&self, slot: Slot) -> bool {
self.roots_tracker.read().unwrap().roots.contains(&slot) self.roots_tracker
.read()
.unwrap()
.alive_roots
.contains(&slot)
} }
pub fn add_root(&self, slot: Slot, caching_enabled: bool) { pub fn add_root(&self, slot: Slot, caching_enabled: bool) {
let mut w_roots_tracker = self.roots_tracker.write().unwrap(); let mut w_roots_tracker = self.roots_tracker.write().unwrap();
// `AccountsDb::flush_accounts_cache()` relies on roots being added in order // `AccountsDb::flush_accounts_cache()` relies on roots being added in order
assert!(slot >= w_roots_tracker.roots.max_inclusive()); assert!(slot >= w_roots_tracker.alive_roots.max_inclusive());
// 'slot' is a root, so it is both 'root' and 'original' // 'slot' is a root, so it is both 'root' and 'original'
w_roots_tracker.roots.insert(slot); w_roots_tracker.alive_roots.insert(slot);
w_roots_tracker.roots_original.insert(slot); w_roots_tracker.roots_original.insert(slot);
// we delay cleaning until flushing! // we delay cleaning until flushing!
if !caching_enabled { if !caching_enabled {
@ -1706,7 +1714,11 @@ impl<T: IndexValue> AccountsIndex<T> {
} }
pub fn max_root_inclusive(&self) -> Slot { pub fn max_root_inclusive(&self) -> Slot {
self.roots_tracker.read().unwrap().roots.max_inclusive() self.roots_tracker
.read()
.unwrap()
.alive_roots
.max_inclusive()
} }
/// return the lowest original root >= slot, including roots_original and ancestors /// return the lowest original root >= slot, including roots_original and ancestors
@ -1762,7 +1774,7 @@ impl<T: IndexValue> AccountsIndex<T> {
let removed_from_unclean_roots = w_roots_tracker.uncleaned_roots.remove(&slot); let removed_from_unclean_roots = w_roots_tracker.uncleaned_roots.remove(&slot);
let removed_from_previous_uncleaned_roots = let removed_from_previous_uncleaned_roots =
w_roots_tracker.previous_uncleaned_roots.remove(&slot); w_roots_tracker.previous_uncleaned_roots.remove(&slot);
if !w_roots_tracker.roots.remove(&slot) { if !w_roots_tracker.alive_roots.remove(&slot) {
if removed_from_unclean_roots { if removed_from_unclean_roots {
error!("clean_dead_slot-removed_from_unclean_roots: {}", slot); error!("clean_dead_slot-removed_from_unclean_roots: {}", slot);
inc_new_counter_error!("clean_dead_slot-removed_from_unclean_roots", 1, 1); inc_new_counter_error!("clean_dead_slot-removed_from_unclean_roots", 1, 1);
@ -1780,16 +1792,16 @@ impl<T: IndexValue> AccountsIndex<T> {
} }
false false
} else { } else {
stats.roots_len = w_roots_tracker.roots.len(); stats.roots_len = w_roots_tracker.alive_roots.len();
stats.uncleaned_roots_len = w_roots_tracker.uncleaned_roots.len(); stats.uncleaned_roots_len = w_roots_tracker.uncleaned_roots.len();
stats.previous_uncleaned_roots_len = w_roots_tracker.previous_uncleaned_roots.len(); stats.previous_uncleaned_roots_len = w_roots_tracker.previous_uncleaned_roots.len();
stats.roots_range = w_roots_tracker.roots.range_width(); stats.roots_range = w_roots_tracker.alive_roots.range_width();
true true
} }
} }
pub fn min_root(&self) -> Option<Slot> { pub fn min_alive_root(&self) -> Option<Slot> {
self.roots_tracker.read().unwrap().min_root() self.roots_tracker.read().unwrap().min_alive_root()
} }
pub fn reset_uncleaned_roots(&self, max_clean_root: Option<Slot>) -> HashSet<Slot> { pub fn reset_uncleaned_roots(&self, max_clean_root: Option<Slot>) -> HashSet<Slot> {
@ -1833,18 +1845,18 @@ impl<T: IndexValue> AccountsIndex<T> {
.contains(&slot) .contains(&slot)
} }
pub fn num_roots(&self) -> usize { pub fn num_alive_roots(&self) -> usize {
self.roots_tracker.read().unwrap().roots.len() self.roots_tracker.read().unwrap().alive_roots.len()
} }
pub fn all_roots(&self) -> Vec<Slot> { pub fn all_alive_roots(&self) -> Vec<Slot> {
let tracker = self.roots_tracker.read().unwrap(); let tracker = self.roots_tracker.read().unwrap();
tracker.roots.get_all() tracker.alive_roots.get_all()
} }
#[cfg(test)] #[cfg(test)]
pub fn clear_roots(&self) { pub fn clear_roots(&self) {
self.roots_tracker.write().unwrap().roots.clear() self.roots_tracker.write().unwrap().alive_roots.clear()
} }
pub fn clone_uncleaned_roots(&self) -> HashSet<Slot> { pub fn clone_uncleaned_roots(&self) -> HashSet<Slot> {
@ -1862,7 +1874,7 @@ impl<T: IndexValue> AccountsIndex<T> {
pub fn purge_roots(&self, pubkey: &Pubkey) -> (SlotList<T>, bool) { pub fn purge_roots(&self, pubkey: &Pubkey) -> (SlotList<T>, bool) {
self.slot_list_mut(pubkey, |slot_list| { self.slot_list_mut(pubkey, |slot_list| {
let reclaims = self.get_rooted_entries(slot_list, None); let reclaims = self.get_rooted_entries(slot_list, None);
slot_list.retain(|(slot, _)| !self.is_root(*slot)); slot_list.retain(|(slot, _)| !self.is_alive_root(*slot));
(reclaims, slot_list.is_empty()) (reclaims, slot_list.is_empty())
}) })
.unwrap() .unwrap()
@ -2799,11 +2811,11 @@ pub mod tests {
} }
#[test] #[test]
fn test_is_root() { fn test_is_alive_root() {
let index = AccountsIndex::<bool>::default_for_tests(); let index = AccountsIndex::<bool>::default_for_tests();
assert!(!index.is_root(0)); assert!(!index.is_alive_root(0));
index.add_root(0, false); index.add_root(0, false);
assert!(index.is_root(0)); assert!(index.is_alive_root(0));
} }
#[test] #[test]
@ -2834,8 +2846,8 @@ pub mod tests {
index.add_root(0, false); index.add_root(0, false);
index.add_root(1, false); index.add_root(1, false);
index.clean_dead_slot(0, &mut AccountsIndexRootsStats::default()); index.clean_dead_slot(0, &mut AccountsIndexRootsStats::default());
assert!(index.is_root(1)); assert!(index.is_alive_root(1));
assert!(!index.is_root(0)); assert!(!index.is_alive_root(0));
} }
#[test] #[test]
@ -2845,8 +2857,8 @@ pub mod tests {
index.add_root(0, false); index.add_root(0, false);
index.add_root(1, false); index.add_root(1, false);
index.clean_dead_slot(1, &mut AccountsIndexRootsStats::default()); index.clean_dead_slot(1, &mut AccountsIndexRootsStats::default());
assert!(!index.is_root(1)); assert!(!index.is_alive_root(1));
assert!(index.is_root(0)); assert!(index.is_alive_root(0));
} }
#[test] #[test]
@ -2867,7 +2879,7 @@ pub mod tests {
.len() .len()
); );
index.reset_uncleaned_roots(None); index.reset_uncleaned_roots(None);
assert_eq!(2, index.roots_tracker.read().unwrap().roots.len()); assert_eq!(2, index.roots_tracker.read().unwrap().alive_roots.len());
assert_eq!(0, index.roots_tracker.read().unwrap().uncleaned_roots.len()); assert_eq!(0, index.roots_tracker.read().unwrap().uncleaned_roots.len());
assert_eq!( assert_eq!(
2, 2,
@ -2881,7 +2893,7 @@ pub mod tests {
index.add_root(2, false); index.add_root(2, false);
index.add_root(3, false); index.add_root(3, false);
assert_eq!(4, index.roots_tracker.read().unwrap().roots.len()); assert_eq!(4, index.roots_tracker.read().unwrap().alive_roots.len());
assert_eq!(2, index.roots_tracker.read().unwrap().uncleaned_roots.len()); assert_eq!(2, index.roots_tracker.read().unwrap().uncleaned_roots.len());
assert_eq!( assert_eq!(
2, 2,
@ -2894,7 +2906,7 @@ pub mod tests {
); );
index.clean_dead_slot(1, &mut AccountsIndexRootsStats::default()); index.clean_dead_slot(1, &mut AccountsIndexRootsStats::default());
assert_eq!(3, index.roots_tracker.read().unwrap().roots.len()); assert_eq!(3, index.roots_tracker.read().unwrap().alive_roots.len());
assert_eq!(2, index.roots_tracker.read().unwrap().uncleaned_roots.len()); assert_eq!(2, index.roots_tracker.read().unwrap().uncleaned_roots.len());
assert_eq!( assert_eq!(
1, 1,
@ -2907,7 +2919,7 @@ pub mod tests {
); );
index.clean_dead_slot(2, &mut AccountsIndexRootsStats::default()); index.clean_dead_slot(2, &mut AccountsIndexRootsStats::default());
assert_eq!(2, index.roots_tracker.read().unwrap().roots.len()); assert_eq!(2, index.roots_tracker.read().unwrap().alive_roots.len());
assert_eq!(1, index.roots_tracker.read().unwrap().uncleaned_roots.len()); assert_eq!(1, index.roots_tracker.read().unwrap().uncleaned_roots.len());
assert_eq!( assert_eq!(
1, 1,

2
runtime/src/serde_snapshot/newer.rs
View File

@ -245,7 +245,7 @@ impl<'a> TypeContext<'a> for Context {
.roots_tracker .roots_tracker
.read() .read()
.unwrap() .unwrap()
.roots .alive_roots
.get_all(); .get_all();
let prior_roots_with_hash = Vec::<(Slot, Hash)>::default(); let prior_roots_with_hash = Vec::<(Slot, Hash)>::default();