disable read cache

Author: HaoranYi

accounts-db/src/read_only_accounts_cache.rs

@@ -176,6 +176,7 @@ impl ReadOnlyAccountsCache {
     }
 
     pub(crate) fn store(&self, pubkey: Pubkey, slot: Slot, account: AccountSharedData) {
+        panic!("haha");
         let measure_store = Measure::start("");
         self.highest_slot_stored.fetch_max(slot, Ordering::Release);
         let account_size = Self::account_size(&account);

runtime/src/bank.rs

@@ -1820,7 +1820,7 @@ impl Bank {
     where
         F: Fn(&Option<AccountSharedData>) -> AccountSharedData,
     {
-        let old_account = self.get_account_with_fixed_root(pubkey);
+        let old_account = self.get_account_with_fixed_root_no_cache(pubkey);
         let mut new_account = updater(&old_account);
 
         // When new sysvar comes into existence (with RENT_UNADJUSTED_INITIAL_BALANCE lamports),
@@ -2338,7 +2338,7 @@ impl Bank {
             // already have been cached in cached_vote_accounts; so the code
             // below is only for sanity check, and can be removed once
             // vote_accounts_cache_miss_count is shown to be always zero.
-            let account = self.get_account_with_fixed_root(vote_pubkey)?;
+            let account = self.get_account_with_fixed_root_no_cache(vote_pubkey)?;
             if account.owner() == &solana_vote_program
                 && VoteState::deserialize(account.data()).is_ok()
             {
@@ -3011,7 +3011,7 @@ impl Bank {
 
     // Used by tests to simulate clusters with precompiles that aren't owned by the native loader
     fn add_precompiled_account_with_owner(&self, program_id: &Pubkey, owner: Pubkey) {
-        if let Some(account) = self.get_account_with_fixed_root(program_id) {
+        if let Some(account) = self.get_account_with_fixed_root_no_cache(program_id) {
             if account.executable() {
                 return;
             } else {
@@ -3610,7 +3610,7 @@ impl Bank {
 
     fn check_message_for_nonce(&self, message: &SanitizedMessage) -> Option<TransactionAccount> {
         let nonce_address = message.get_durable_nonce()?;
-        let nonce_account = self.get_account_with_fixed_root(nonce_address)?;
+        let nonce_account = self.get_account_with_fixed_root_no_cache(nonce_address)?;
         let nonce_data =
             nonce_account::verify_nonce_account(&nonce_account, message.recent_blockhash())?;
 
@@ -5080,7 +5080,7 @@ impl Bank {
         new_account: &AccountSharedData,
     ) {
         let old_account_data_size =
-            if let Some(old_account) = self.get_account_with_fixed_root(pubkey) {
+            if let Some(old_account) = self.get_account_with_fixed_root_no_cache(pubkey) {
                 match new_account.lamports().cmp(&old_account.lamports()) {
                     std::cmp::Ordering::Greater => {
                         let increased = new_account.lamports() - old_account.lamports();
@@ -5122,7 +5122,7 @@ impl Bank {
     }
 
     fn withdraw(&self, pubkey: &Pubkey, lamports: u64) -> Result<()> {
-        match self.get_account_with_fixed_root(pubkey) {
+        match self.get_account_with_fixed_root_no_cache(pubkey) {
             Some(mut account) => {
                 let min_balance = match get_system_account_kind(&account) {
                     Some(SystemAccountKind::Nonce) => self
@@ -5248,6 +5248,14 @@ impl Bank {
         }
     }
 
+    pub fn get_account_with_fixed_root_no_cache(
+        &self,
+        pubkey: &Pubkey,
+    ) -> Option<AccountSharedData> {
+        self.load_account_with(pubkey, |_| false)
+            .map(|(acc, _slot)| acc)
+    }
+
     // Hi! leaky abstraction here....
     // try to use get_account_with_fixed_root() if it's called ONLY from on-chain runtime account
     // processing. That alternative fn provides more safety.
@@ -6427,7 +6435,7 @@ impl Bank {
 
         // Update activation slot of features in `new_feature_activations`
         for feature_id in new_feature_activations.iter() {
-            if let Some(mut account) = self.get_account_with_fixed_root(feature_id) {
+            if let Some(mut account) = self.get_account_with_fixed_root_no_cache(feature_id) {
                 if let Some(mut feature) = feature::from_account(&account) {
                     feature.activated_at = Some(self.slot());
                     if feature::to_account(&feature, &mut account).is_some() {
@@ -6516,7 +6524,7 @@ impl Bank {
 
         for feature_id in &self.feature_set.inactive {
             let mut activated = None;
-            if let Some(account) = self.get_account_with_fixed_root(feature_id) {
+            if let Some(account) = self.get_account_with_fixed_root_no_cache(feature_id) {
                 if let Some(feature) = feature::from_account(&account) {
                     match feature.activated_at {
                         None if include_pending => {
@@ -6653,8 +6661,8 @@ impl Bank {
         new_address: &Pubkey,
         datapoint_name: &'static str,
     ) {
-        if let Some(old_account) = self.get_account_with_fixed_root(old_address) {
-            if let Some(new_account) = self.get_account_with_fixed_root(new_address) {
+        if let Some(old_account) = self.get_account_with_fixed_root_no_cache(old_address) {
+            if let Some(new_account) = self.get_account_with_fixed_root_no_cache(new_address) {
                 datapoint_info!(datapoint_name, ("slot", self.slot, i64));
 
                 // Burn lamports in the old account

runtime/src/bank/builtins/core_bpf_migration/source_buffer.rs

@@ -25,7 +25,7 @@ impl SourceBuffer {
     ) -> Result<Self, CoreBpfMigrationError> {
         // The buffer account should exist.
         let buffer_account = bank
-            .get_account_with_fixed_root(buffer_address)
+            .get_account_with_fixed_root_no_cache(buffer_address)
             .ok_or(CoreBpfMigrationError::AccountNotFound(*buffer_address))?;
 
         // The buffer account should be owned by the upgradeable loader.

runtime/src/bank/builtins/core_bpf_migration/target_builtin.rs

@@ -29,7 +29,7 @@ impl TargetBuiltin {
             CoreBpfMigrationTargetType::Builtin => {
                 // The program account should exist.
                 let program_account = bank
-                    .get_account_with_fixed_root(program_address)
+                    .get_account_with_fixed_root_no_cache(program_address)
                     .ok_or(CoreBpfMigrationError::AccountNotFound(*program_address))?;
 
                 // The program account should be owned by the native loader.
@@ -41,7 +41,10 @@ impl TargetBuiltin {
             }
             CoreBpfMigrationTargetType::Stateless => {
                 // The program account should _not_ exist.
-                if bank.get_account_with_fixed_root(program_address).is_some() {
+                if bank
+                    .get_account_with_fixed_root_no_cache(program_address)
+                    .is_some()
+                {
                     return Err(CoreBpfMigrationError::AccountExists(*program_address));
                 }
 
@@ -53,7 +56,7 @@ impl TargetBuiltin {
 
         // The program data account should not exist.
         if bank
-            .get_account_with_fixed_root(&program_data_address)
+            .get_account_with_fixed_root_no_cache(&program_data_address)
             .is_some()
         {
             return Err(CoreBpfMigrationError::ProgramHasDataAccount(

runtime/src/bank/fee_distribution.rs

@@ -168,7 +168,9 @@ impl Bank {
         fees: u64,
         options: DepositFeeOptions,
     ) -> Result<u64, DepositFeeError> {
-        let mut account = self.get_account_with_fixed_root(pubkey).unwrap_or_default();
+        let mut account = self
+            .get_account_with_fixed_root_no_cache(pubkey)
+            .unwrap_or_default();
 
         if options.check_account_owner && !system_program::check_id(account.owner()) {
             return Err(DepositFeeError::InvalidAccountOwner);

runtime/src/bank/partitioned_epoch_rewards/calculation.rs

@@ -356,7 +356,7 @@ impl Bank {
             // already have been cached in cached_vote_accounts; so the code
             // below is only for sanity checking, and can be removed once
             // the cache is deemed to be reliable.
-            let account = self.get_account_with_fixed_root(vote_pubkey)?;
+            let account = self.get_account_with_fixed_root_no_cache(vote_pubkey)?;
             VoteAccount::try_from(account).ok()
         };
 
@@ -485,7 +485,7 @@ impl Bank {
             // already have been cached in cached_vote_accounts; so the code
             // below is only for sanity checking, and can be removed once
             // the cache is deemed to be reliable.
-            let account = self.get_account_with_fixed_root(vote_pubkey)?;
+            let account = self.get_account_with_fixed_root_no_cache(vote_pubkey)?;
             VoteAccount::try_from(account).ok()
         };
 

svm/src/account_loader.rs

@@ -6,10 +6,7 @@ use {
         transaction_error_metrics::TransactionErrorMetrics,
         transaction_processing_callback::TransactionProcessingCallback,
     },
-    solana_program_runtime::{
-        compute_budget_processor::process_compute_budget_instructions,
-        loaded_programs::ProgramCacheEntry,
-    },
+    solana_program_runtime::compute_budget_processor::process_compute_budget_instructions,
     solana_sdk::{
         account::{Account, AccountSharedData, ReadableAccount, WritableAccount},
         feature_set::{
@@ -222,7 +219,8 @@ fn load_transaction_accounts<CB: TransactionProcessingCallback>(
                     callbacks
                         .load_account_with(key, |account| {
                             // only cache non program accounts
-                            !program_owners.contains(account.owner())
+                            // !program_owners.contains(account.owner())
+                            false
                         })
                         .map(|(mut account, _slot)| {
                             if program_owners.contains(account.owner()) {
@@ -350,7 +348,9 @@ fn load_transaction_accounts<CB: TransactionProcessingCallback>(
                 builtins_start_index.saturating_add(owner_index)
             } else {
                 let owner_index = accounts.len();
-                if let Some(owner_account) = callbacks.get_account_shared_data(owner_id) {
+                if let Some((owner_account, _slot)) =
+                    callbacks.load_account_with(owner_id, |_| false)
+                {
                     if !native_loader::check_id(owner_account.owner())
                         || !owner_account.executable()
                     {

svm/src/transaction_processor.rs

@@ -668,7 +668,7 @@ impl<FG: ForkGraph> TransactionBatchProcessor<FG> {
     ) {
         let mut sysvar_cache = self.sysvar_cache.write().unwrap();
         sysvar_cache.fill_missing_entries(|pubkey, set_sysvar| {
-            if let Some(account) = callbacks.get_account_shared_data(pubkey) {
+            if let Some((account, _slot)) = callbacks.load_account_with(pubkey, |_| false) {
                 set_sysvar(account.data());
             }
         });