ancient add write_one_packed_storage (#30220)

runtime/src/ancient_append_vecs.rs

@@ -9,10 +9,11 @@ use {
         accounts_db::{
             AccountStorageEntry, AccountsDb, AliveAccounts, GetUniqueAccountsResult, ShrinkCollect,
             ShrinkCollectAliveSeparatedByRefs, ShrinkStatsSub, StoreReclaims,
+            INCLUDE_SLOT_IN_HASH_IRRELEVANT_APPEND_VEC_OPERATION,
         },
         accounts_index::ZeroLamport,
         append_vec::{AppendVec, StoredAccountMeta},
-        storable_accounts::StorableAccounts,
+        storable_accounts::{StorableAccounts, StorableAccountsBySlot},
     },
     rand::{thread_rng, Rng},
     solana_measure::{measure, measure_us},
@@ -222,6 +223,15 @@ struct WriteAncientAccounts<'a> {
     metrics: ShrinkStatsSub,
 }
 
+impl<'a> WriteAncientAccounts<'a> {
+    pub(crate) fn accumulate(&mut self, mut other: Self) {
+        self.metrics.accumulate(&other.metrics);
+        other.shrinks_in_progress.drain().for_each(|(k, v)| {
+            self.shrinks_in_progress.insert(k, v);
+        });
+    }
+}
+
 impl AccountsDb {
     /// calculate all storage info for the storages in slots
     /// Then, apply 'tuning' to filter out slots we do NOT want to combine.
@@ -348,6 +358,29 @@ impl AccountsDb {
             target_slots,
         }
     }
+
+    /// create packed storage and write contents of 'packed' to it.
+    /// accumulate results in 'write_ancient_accounts'
+    #[allow(dead_code)]
+    fn write_one_packed_storage<'a, 'b: 'a>(
+        &'b self,
+        packed: &'a PackedAncientStorage<'a>,
+        target_slot: Slot,
+        write_ancient_accounts: &mut WriteAncientAccounts<'b>,
+    ) {
+        let PackedAncientStorage {
+            bytes: bytes_total,
+            accounts: accounts_to_write,
+        } = packed;
+        let accounts_to_write = StorableAccountsBySlot::new(
+            target_slot,
+            &accounts_to_write[..],
+            INCLUDE_SLOT_IN_HASH_IRRELEVANT_APPEND_VEC_OPERATION,
+        );
+
+        write_ancient_accounts
+            .accumulate(self.write_ancient_accounts(*bytes_total, accounts_to_write))
+    }
 }
 
 /// hold all alive accounts to be shrunk and/or combined
@@ -372,6 +405,16 @@ struct AccountsToCombine<'a> {
     target_slots: Vec<Slot>,
 }
 
+#[allow(dead_code)]
+#[derive(Default)]
+/// intended contents of a packed ancient storage
+struct PackedAncientStorage<'a> {
+    /// accounts to move into this storage, along with the slot the accounts are currently stored in
+    accounts: Vec<(Slot, &'a [&'a StoredAccountMeta<'a>])>,
+    /// total bytes required to hold 'accounts'
+    bytes: u64,
+}
+
 /// a set of accounts need to be stored.
 /// If there are too many to fit in 'Primary', the rest are put in 'Overflow'
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -1399,16 +1442,24 @@ pub mod tests {
         );
     }
 
+    #[derive(EnumIter, Debug, PartialEq, Eq)]
+    enum TestWriteAncient {
+        OnePackedStorage,
+        AncientAccounts,
+    }
+
     #[test]
     fn test_write_ancient_accounts() {
         for data_size in [None, Some(10_000_000)] {
+            for method in TestWriteAncient::iter() {
                 for num_slots in 0..4 {
                     for combine_into in 0..=num_slots {
                         if combine_into == num_slots && num_slots > 0 {
                             // invalid combination when num_slots > 0, but required to hit num_slots=0, combine_into=0
                             continue;
                         }
-                    let (db, storages, slots, _infos) = get_sample_storages(num_slots, data_size);
+                        let (db, storages, slots, _infos) =
+                            get_sample_storages(num_slots, data_size);
 
                         let initial_accounts = get_all_accounts(&db, slots.clone());
 
@@ -1446,9 +1497,24 @@ pub mod tests {
                     );
 
                         if num_slots > 0 {
-                        let mut result = db
+                            let mut result = match method {
-                            .write_ancient_accounts(bytes, accounts_to_write)
+                                TestWriteAncient::AncientAccounts => {
-                            .shrinks_in_progress;
+                                    db.write_ancient_accounts(bytes, accounts_to_write)
+                                        .shrinks_in_progress
+                                }
+                                TestWriteAncient::OnePackedStorage => {
+                                    let mut write_ancient_accounts =
+                                        WriteAncientAccounts::default();
+
+                                    let packed = PackedAncientStorage { accounts, bytes };
+                                    db.write_one_packed_storage(
+                                        &packed,
+                                        target_slot,
+                                        &mut write_ancient_accounts,
+                                    );
+                                    write_ancient_accounts.shrinks_in_progress
+                                }
+                            };
                             let one = result.drain().collect::<Vec<_>>();
                             assert_eq!(1, one.len());
                             assert_eq!(target_slot, one.first().unwrap().0);
@@ -1474,6 +1540,7 @@ pub mod tests {
                 }
             }
         }
+    }
 
     #[test]
     fn test_filter_ancient_slots() {}