update ledger tool to restore cost table from blockstore

core/src/cost_model.rs

@@ -91,6 +91,29 @@ impl CostModel {
         self.block_cost_limit
     }
 
+    pub fn initialize_cost_table(&mut self, cost_table: &[(Pubkey, u64)]) {
+        for (program_id, cost) in cost_table {
+            match self.upsert_instruction_cost(program_id, cost) {
+                Ok(c) => {
+                    debug!(
+                        "initiating cost table, instruction {:?} has cost {}",
+                        program_id, c
+                    );
+                }
+                Err(err) => {
+                    debug!(
+                        "initiating cost table, failed for instruction {:?}, err: {}",
+                        program_id, err
+                    );
+                }
+            }
+        }
+        debug!(
+            "restored cost model instruction cost table from blockstore, current values: {:?}",
+            self.get_instruction_cost_table()
+        );
+    }
+
     pub fn calculate_cost(&mut self, transaction: &Transaction) -> &TransactionCost {
         self.transaction_cost.reset();
 
@@ -450,4 +473,33 @@ mod tests {
             th.join().unwrap();
         }
     }
+
+    #[test]
+    fn test_cost_model_init_cost_table() {
+        // build cost table
+        let instruction_ids = vec![
+            Pubkey::new_unique(),
+            Pubkey::new_unique(),
+            Pubkey::new_unique(),
+        ];
+        let instruction_costs = vec![10, 20, 30];
+        let cost_table: Vec<(Pubkey, u64)> = instruction_ids
+            .iter()
+            .enumerate()
+            .map(|(index, id)| (*id, instruction_costs[index]))
+            .collect();
+
+        // init cost model
+        let mut cost_model = CostModel::default();
+        cost_model.initialize_cost_table(&cost_table);
+        let cost_model = Arc::new(RwLock::new(cost_model));
+
+        // verify
+        instruction_ids.iter().enumerate().for_each(|(index, id)| {
+            assert_eq!(
+                instruction_costs[index],
+                cost_model.read().unwrap().find_instruction_cost(id)
+            );
+        });
+    }
 }

core/src/validator.rs

@@ -6,7 +6,7 @@ use crate::{
     cluster_info_vote_listener::VoteTracker,
     completed_data_sets_service::CompletedDataSetsService,
     consensus::{reconcile_blockstore_roots_with_tower, Tower},
-    cost_model::{CostModel, ACCOUNT_MAX_COST, BLOCK_MAX_COST},
+    cost_model::CostModel,
     rewards_recorder_service::{RewardsRecorderSender, RewardsRecorderService},
     sample_performance_service::SamplePerformanceService,
     serve_repair::ServeRepair,
@@ -659,11 +659,9 @@ impl Validator {
             bank_forks.read().unwrap().root_bank().deref(),
         ));
 
-        let cost_model = Arc::new(RwLock::new(CostModel::new(
-            ACCOUNT_MAX_COST,
-            BLOCK_MAX_COST,
-        )));
-        Self::initiate_cost_model(&cost_model, &blockstore.read_program_costs().unwrap());
+        let mut cost_model = CostModel::default();
+        cost_model.initialize_cost_table(&blockstore.read_program_costs().unwrap());
+        let cost_model = Arc::new(RwLock::new(cost_model));
 
         let (retransmit_slots_sender, retransmit_slots_receiver) = unbounded();
         let (verified_vote_sender, verified_vote_receiver) = unbounded();
@@ -897,31 +895,6 @@ impl Validator {
             ip_echo_server.shutdown_background();
         }
     }
-
-    fn initiate_cost_model(cost_model: &RwLock<CostModel>, cost_table: &[(Pubkey, u64)]) {
-        let mut cost_model_mutable = cost_model.write().unwrap();
-        for (program_id, cost) in cost_table {
-            match cost_model_mutable.upsert_instruction_cost(program_id, cost) {
-                Ok(c) => {
-                    debug!(
-                        "initiating cost table, instruction {:?} has cost {}",
-                        program_id, c
-                    );
-                }
-                Err(err) => {
-                    debug!(
-                        "initiating cost table, failed for instruction {:?}, err: {}",
-                        program_id, err
-                    );
-                }
-            }
-        }
-        drop(cost_model_mutable);
-        debug!(
-            "restored cost model instruction cost table from blockstore, current values: {:?}",
-            cost_model.read().unwrap().get_instruction_cost_table()
-        );
-    }
 }
 
 fn active_vote_account_exists_in_bank(bank: &Arc<Bank>, vote_account: &Pubkey) -> bool {

ledger-tool/src/main.rs

@@ -14,7 +14,7 @@ use solana_clap_utils::{
         is_parsable, is_pubkey, is_pubkey_or_keypair, is_slot, is_valid_percentage,
     },
 };
-use solana_core::cost_model::{CostModel, ACCOUNT_MAX_COST, BLOCK_MAX_COST};
+use solana_core::cost_model::CostModel;
 use solana_core::cost_tracker::CostTracker;
 use solana_ledger::entry::Entry;
 use solana_ledger::{
@@ -737,10 +737,9 @@ fn compute_slot_cost(blockstore: &Blockstore, slot: Slot) -> Result<(), String>
     let mut transactions = 0;
     let mut programs = 0;
     let mut program_ids = HashMap::new();
-    let cost_model = Arc::new(RwLock::new(CostModel::new(
-        ACCOUNT_MAX_COST,
-        BLOCK_MAX_COST,
-    )));
+    let mut cost_model = CostModel::default();
+    cost_model.initialize_cost_table(&blockstore.read_program_costs().unwrap());
+    let cost_model = Arc::new(RwLock::new(cost_model));
     let mut cost_tracker = CostTracker::new(cost_model.clone());
 
     for entry in &entries {