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

2
runtime/src/bank.rs
View File

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

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

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