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

Removes unused `ancestors` param from `get_snapshot_storages` (#30773)

This commit is contained in:
Brooks 2023-03-18 17:17:41 -04:00 committed by GitHub
parent 8325b0f591
commit d3273ba118
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
4 changed files with 26 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
runtime/src/accounts_db.rs
View File

@ -7266,7 +7266,7 @@ impl AccountsDb {
}
let mut collect_time = Measure::start("collect");
let (combined_maps, slots) = self.get_snapshot_storages(..=slot, config.ancestors);
let (combined_maps, slots) = self.get_snapshot_storages(..=slot);
collect_time.stop();
let mut sort_time = Measure::start("sort_storages");
@ -7720,10 +7720,8 @@ impl AccountsDb {
if let Some((base_slot, base_capitalization)) = base {
self.verify_accounts_hash_and_lamports(base_slot, base_capitalization, None, config)?;
let (storages, slots) = self.get_snapshot_storages(
base_slot.checked_add(1).unwrap()..=slot,
calc_config.ancestors,
);
let (storages, slots) =
self.get_snapshot_storages(base_slot.checked_add(1).unwrap()..=slot);
let sorted_storages =
SortedStorages::new_with_slots(storages.iter().zip(slots.into_iter()), None, None);
let calculated_incremental_accounts_hash = self.calculate_incremental_accounts_hash(
@ -8660,8 +8658,6 @@ impl AccountsDb {
pub fn get_snapshot_storages(
&self,
requested_slots: impl RangeBounds<Slot> + Sync,
// ancestors is unused and will be removed from callers next
_ancestors: Option<&Ancestors>,
) -> (Vec<Arc<AccountStorageEntry>>, Vec<Slot>) {
let mut m = Measure::start("get slots");
let mut slots_and_storages = self
@ -10041,7 +10037,7 @@ pub mod tests {
accounts.store_for_tests(slot, &to_store[..]);
accounts.add_root_and_flush_write_cache(slot);
let (storages, slots) = accounts.get_snapshot_storages(..=slot, None);
let (storages, slots) = accounts.get_snapshot_storages(..=slot);
assert_eq!(storages.len(), slots.len());
storages
.iter()
@ -12860,7 +12856,7 @@ pub mod tests {
#[test]
fn test_get_snapshot_storages_empty() {
let db = AccountsDb::new(Vec::new(), &ClusterType::Development);
assert!(db.get_snapshot_storages(..=0, None).0.is_empty());
assert!(db.get_snapshot_storages(..=0).0.is_empty());
}
#[test]
@ -12875,10 +12871,10 @@ pub mod tests {
db.store_for_tests(base_slot, &[(&key, &account)]);
db.add_root_and_flush_write_cache(base_slot);
assert!(db.get_snapshot_storages(..=before_slot, None).0.is_empty());
assert!(db.get_snapshot_storages(..=before_slot).0.is_empty());
assert_eq!(1, db.get_snapshot_storages(..=base_slot, None).0.len());
assert_eq!(1, db.get_snapshot_storages(..=after_slot, None).0.len());
assert_eq!(1, db.get_snapshot_storages(..=base_slot).0.len());
assert_eq!(1, db.get_snapshot_storages(..=after_slot).0.len());
}
#[test]
@ -12895,13 +12891,13 @@ pub mod tests {
if pass == 0 {
db.add_root_and_flush_write_cache(base_slot);
db.storage.remove(&base_slot, false);
assert!(db.get_snapshot_storages(..=after_slot, None).0.is_empty());
assert!(db.get_snapshot_storages(..=after_slot).0.is_empty());
continue;
}
db.store_for_tests(base_slot, &[(&key, &account)]);
db.add_root_and_flush_write_cache(base_slot);
assert_eq!(1, db.get_snapshot_storages(..=after_slot, None).0.len());
assert_eq!(1, db.get_snapshot_storages(..=after_slot).0.len());
}
}
@ -12915,10 +12911,10 @@ pub mod tests {
let after_slot = base_slot + 1;
db.store_for_tests(base_slot, &[(&key, &account)]);
assert!(db.get_snapshot_storages(..=after_slot, None).0.is_empty());
assert!(db.get_snapshot_storages(..=after_slot).0.is_empty());
db.add_root_and_flush_write_cache(base_slot);
assert_eq!(1, db.get_snapshot_storages(..=after_slot, None).0.len());
assert_eq!(1, db.get_snapshot_storages(..=after_slot).0.len());
}
#[test]
@ -12932,13 +12928,13 @@ pub mod tests {
db.store_for_tests(base_slot, &[(&key, &account)]);
db.add_root_and_flush_write_cache(base_slot);
assert_eq!(1, db.get_snapshot_storages(..=after_slot, None).0.len());
assert_eq!(1, db.get_snapshot_storages(..=after_slot).0.len());
db.storage
.get_slot_storage_entry(0)
.unwrap()
.remove_account(0, true);
assert!(db.get_snapshot_storages(..=after_slot, None).0.is_empty());
assert!(db.get_snapshot_storages(..=after_slot).0.is_empty());
}
#[test]
@ -12951,11 +12947,8 @@ pub mod tests {
let slot = 10;
db.store_for_tests(slot, &[(&key, &account)]);
db.add_root_and_flush_write_cache(slot);
assert_eq!(
0,
db.get_snapshot_storages(slot + 1..=slot + 1, None).0.len()
);
assert_eq!(1, db.get_snapshot_storages(slot..=slot + 1, None).0.len());
assert_eq!(0, db.get_snapshot_storages(slot + 1..=slot + 1).0.len());
assert_eq!(1, db.get_snapshot_storages(slot..=slot + 1).0.len());
}
#[test]
@ -13119,7 +13112,7 @@ pub mod tests {
accounts.store_for_tests(current_slot, &[(&pubkey2, &zero_lamport_account)]);
accounts.store_for_tests(current_slot, &[(&pubkey3, &zero_lamport_account)]);
let snapshot_stores = accounts.get_snapshot_storages(..=current_slot, None).0;
let snapshot_stores = accounts.get_snapshot_storages(..=current_slot).0;
let total_accounts: usize = snapshot_stores.iter().map(|s| s.all_accounts().len()).sum();
assert!(!snapshot_stores.is_empty());
assert!(total_accounts > 0);
@ -18136,7 +18129,7 @@ pub mod tests {
// calculate the full accounts hash
let full_accounts_hash = {
accounts_db.clean_accounts(Some(slot - 1), false, None);
let (storages, _) = accounts_db.get_snapshot_storages(..=slot, None);
let (storages, _) = accounts_db.get_snapshot_storages(..=slot);
let storages = SortedStorages::new(&storages);
accounts_db
.calculate_accounts_hash_from_storages(
@ -18204,7 +18197,7 @@ pub mod tests {
let incremental_accounts_hash = {
accounts_db.clean_accounts(Some(slot - 1), false, Some(full_accounts_hash_slot));
let (storages, _) =
accounts_db.get_snapshot_storages(full_accounts_hash_slot + 1..=slot, None);
accounts_db.get_snapshot_storages(full_accounts_hash_slot + 1..=slot);
let storages = SortedStorages::new(&storages);
accounts_db
.calculate_incremental_accounts_hash(

2
runtime/src/bank.rs
View File

@ -7070,7 +7070,7 @@ impl Bank {
self.rc
.accounts
.accounts_db
.get_snapshot_storages(requested_slots, None)
.get_snapshot_storages(requested_slots)
.0
}

13
runtime/src/serde_snapshot/tests.rs
View File

@ -43,7 +43,7 @@ fn copy_append_vecs<P: AsRef<Path>>(
accounts_db: &AccountsDb,
output_dir: P,
) -> std::io::Result<StorageAndNextAppendVecId> {
let storage_entries = accounts_db.get_snapshot_storages(RangeFull, None).0;
let storage_entries = accounts_db.get_snapshot_storages(RangeFull).0;
let storage: AccountStorageMap = AccountStorageMap::with_capacity(storage_entries.len());
let mut next_append_vec_id = 0;
for storage_entry in storage_entries.into_iter() {
@ -196,7 +196,7 @@ fn test_accounts_serialize_style(serde_style: SerdeStyle) {
&mut writer,
&accounts.accounts_db,
slot,
&get_storages_to_serialize(&accounts.accounts_db.get_snapshot_storages(..=slot, None).0),
&get_storages_to_serialize(&accounts.accounts_db.get_snapshot_storages(..=slot).0),
)
.unwrap();
@ -434,7 +434,7 @@ pub(crate) fn reconstruct_accounts_db_via_serialization(
slot: Slot,
) -> AccountsDb {
let mut writer = Cursor::new(vec![]);
let snapshot_storages = accounts.get_snapshot_storages(..=slot, None).0;
let snapshot_storages = accounts.get_snapshot_storages(..=slot).0;
accountsdb_to_stream(
SerdeStyle::Newer,
&mut writer,
@ -738,12 +738,7 @@ mod test_bank_serialize {
.accounts
.accounts_db
.set_accounts_hash_for_tests(bank.slot(), AccountsHash(Hash::new_unique()));
let snapshot_storages = bank
.rc
.accounts
.accounts_db
.get_snapshot_storages(..=0, None)
.0;
let snapshot_storages = bank.rc.accounts.accounts_db.get_snapshot_storages(..=0).0;
// ensure there is a single snapshot storage example for ABI digesting
assert_eq!(snapshot_storages.len(), 1);

4
runtime/src/snapshot_minimizer.rs
View File

@ -276,7 +276,7 @@ impl<'a> SnapshotMinimizer<'a> {
) -> (Vec<Slot>, Vec<Arc<AccountStorageEntry>>) {
let snapshot_storages = self
.accounts_db()
.get_snapshot_storages(..=self.starting_slot, None)
.get_snapshot_storages(..=self.starting_slot)
.0;
let dead_slots = Mutex::new(Vec::new());
@ -677,7 +677,7 @@ mod tests {
};
minimizer.minimize_accounts_db();
let snapshot_storages = accounts.get_snapshot_storages(..=current_slot, None).0;
let snapshot_storages = accounts.get_snapshot_storages(..=current_slot).0;
assert_eq!(snapshot_storages.len(), 3);
let mut account_count = 0;