remove IncludeSlotInHash after feature activation on mnb (solana-labs…

…#33816) * remove IncludeSlotInHash after feature activation on mnb * fix compile errors * compile errors * fix tests * fix test results
anza-xyz · Oct 23, 2023 · b0b4e1f · b0b4e1f
1 parent a099c7a
commit b0b4e1f
Show file tree

Hide file tree

Showing 20 changed files with 147 additions and 532 deletions.
diff --git a/accounts-bench/src/main.rs b/accounts-bench/src/main.rs
@@ -9,7 +9,7 @@ use {
         accounts::Accounts,
         accounts_db::{
             test_utils::{create_test_accounts, update_accounts_bench},
-            AccountShrinkThreshold, CalcAccountsHashDataSource, INCLUDE_SLOT_IN_HASH_TESTS,
+            AccountShrinkThreshold, CalcAccountsHashDataSource,
         },
         accounts_index::AccountSecondaryIndexes,
         ancestors::Ancestors,
@@ -134,7 +134,6 @@ fn main() {
                 &EpochSchedule::default(),
                 &RentCollector::default(),
                 true,
-                INCLUDE_SLOT_IN_HASH_TESTS,
             );
             time_store.stop();
             if results != results_store {

diff --git a/accounts-db/benches/append_vec.rs b/accounts-db/benches/append_vec.rs
@@ -7,7 +7,6 @@ use {
         account_storage::meta::{
             StorableAccountsWithHashesAndWriteVersions, StoredAccountInfo, StoredMeta,
         },
-        accounts_db::INCLUDE_SLOT_IN_HASH_TESTS,
         accounts_hash::AccountHash,
         append_vec::{
             test_utils::{create_test_account, get_append_vec_path},
@@ -39,7 +38,7 @@ fn append_account(
     let slot_ignored = Slot::MAX;
     let accounts = [(&storage_meta.pubkey, account)];
     let slice = &accounts[..];
-    let accounts = (slot_ignored, slice, INCLUDE_SLOT_IN_HASH_TESTS);
+    let accounts = (slot_ignored, slice);
     let storable_accounts =
         StorableAccountsWithHashesAndWriteVersions::new_with_hashes_and_write_versions(
             &accounts,

diff --git a/accounts-db/src/accounts.rs b/accounts-db/src/accounts.rs
@@ -3,10 +3,9 @@ use {
         account_overrides::AccountOverrides,
         account_rent_state::{check_rent_state_with_account, RentState},
         accounts_db::{
-            AccountShrinkThreshold, AccountsAddRootTiming, AccountsDb, AccountsDbConfig,
-            IncludeSlotInHash, LoadHint, LoadedAccount, ScanStorageResult,
-            VerifyAccountsHashAndLamportsConfig, ACCOUNTS_DB_CONFIG_FOR_BENCHMARKS,
-            ACCOUNTS_DB_CONFIG_FOR_TESTING,
+            AccountShrinkThreshold, AccountsAddRootTiming, AccountsDb, AccountsDbConfig, LoadHint,
+            LoadedAccount, ScanStorageResult, VerifyAccountsHashAndLamportsConfig,
+            ACCOUNTS_DB_CONFIG_FOR_BENCHMARKS, ACCOUNTS_DB_CONFIG_FOR_TESTING,
         },
         accounts_index::{
             AccountSecondaryIndexes, IndexKey, ScanConfig, ScanError, ScanResult, ZeroLamport,
@@ -1311,7 +1310,6 @@ impl Accounts {
         rent_collector: &RentCollector,
         durable_nonce: &DurableNonce,
         lamports_per_signature: u64,
-        include_slot_in_hash: IncludeSlotInHash,
     ) {
         let (accounts_to_store, transactions) = self.collect_accounts_to_store(
             txs,
@@ -1321,10 +1319,8 @@ impl Accounts {
             durable_nonce,
             lamports_per_signature,
         );
-        self.accounts_db.store_cached_inline_update_index(
-            (slot, &accounts_to_store[..], include_slot_in_hash),
-            Some(&transactions),
-        );
+        self.accounts_db
+            .store_cached_inline_update_index((slot, &accounts_to_store[..]), Some(&transactions));
     }
 
     pub fn store_accounts_cached<'a, T: ReadableAccount + Sync + ZeroLamport + 'a>(

diff --git a/accounts-db/src/accounts_cache.rs b/accounts-db/src/accounts_cache.rs
@@ -1,8 +1,5 @@
 use {
-    crate::{
-        accounts_db::{AccountsDb, IncludeSlotInHash},
-        accounts_hash::AccountHash,
-    },
+    crate::{accounts_db::AccountsDb, accounts_hash::AccountHash},
     dashmap::DashMap,
     seqlock::SeqLock,
     solana_sdk::{
@@ -68,20 +65,12 @@ impl SlotCacheInner {
         self.cache.iter().map(|item| *item.key()).collect()
     }
 
-    pub fn insert(
-        &self,
-        pubkey: &Pubkey,
-        account: AccountSharedData,
-        slot: Slot,
-        include_slot_in_hash: IncludeSlotInHash,
-    ) -> CachedAccount {
+    pub fn insert(&self, pubkey: &Pubkey, account: AccountSharedData) -> CachedAccount {
         let data_len = account.data().len() as u64;
         let item = Arc::new(CachedAccountInner {
             account,
             hash: SeqLock::new(None),
-            slot,
             pubkey: *pubkey,
-            include_slot_in_hash,
         });
         if let Some(old) = self.cache.insert(*pubkey, item.clone()) {
             self.same_account_writes.fetch_add(1, Ordering::Relaxed);
@@ -145,11 +134,7 @@ pub type CachedAccount = Arc<CachedAccountInner>;
 pub struct CachedAccountInner {
     pub account: AccountSharedData,
     hash: SeqLock<Option<AccountHash>>,
-    slot: Slot,
     pubkey: Pubkey,
-    /// temporarily here during feature activation
-    /// since we calculate the hash later, or in the background, we need knowledge of whether this slot uses the slot in the hash or not
-    pub include_slot_in_hash: IncludeSlotInHash,
 }
 
 impl CachedAccountInner {
@@ -158,12 +143,7 @@ impl CachedAccountInner {
         match hash {
             Some(hash) => hash,
             None => {
-                let hash = AccountsDb::hash_account(
-                    self.slot,
-                    &self.account,
-                    &self.pubkey,
-                    self.include_slot_in_hash,
-                );
+                let hash = AccountsDb::hash_account(&self.account, &self.pubkey);
                 *self.hash.lock_write() = Some(hash);
                 hash
             }
@@ -228,13 +208,7 @@ impl AccountsCache {
         );
     }
 
-    pub fn store(
-        &self,
-        slot: Slot,
-        pubkey: &Pubkey,
-        account: AccountSharedData,
-        include_slot_in_hash: IncludeSlotInHash,
-    ) -> CachedAccount {
+    pub fn store(&self, slot: Slot, pubkey: &Pubkey, account: AccountSharedData) -> CachedAccount {
         let slot_cache = self.slot_cache(slot).unwrap_or_else(||
             // DashMap entry.or_insert() returns a RefMut, essentially a write lock,
             // which is dropped after this block ends, minimizing time held by the lock.
@@ -246,7 +220,7 @@ impl AccountsCache {
                 .or_insert(self.new_inner())
                 .clone());
 
-        slot_cache.insert(pubkey, account, slot, include_slot_in_hash)
+        slot_cache.insert(pubkey, account)
     }
 
     pub fn load(&self, slot: Slot, pubkey: &Pubkey) -> Option<CachedAccount> {
@@ -338,7 +312,7 @@ impl AccountsCache {
 
 #[cfg(test)]
 pub mod tests {
-    use {super::*, crate::accounts_db::INCLUDE_SLOT_IN_HASH_TESTS};
+    use super::*;
 
     #[test]
     fn test_remove_slots_le() {
@@ -350,7 +324,6 @@ pub mod tests {
             inserted_slot,
             &Pubkey::new_unique(),
             AccountSharedData::new(1, 0, &Pubkey::default()),
-            INCLUDE_SLOT_IN_HASH_TESTS,
         );
         // If the cache is told the size limit is 0, it should return the one slot
         let removed = cache.remove_slots_le(0);
@@ -368,7 +341,6 @@ pub mod tests {
             inserted_slot,
             &Pubkey::new_unique(),
             AccountSharedData::new(1, 0, &Pubkey::default()),
-            INCLUDE_SLOT_IN_HASH_TESTS,
         );
 
         // If the cache is told the size limit is 0, it should return nothing, because there's no