Bank hash xor

banking_bench/src/main.rs

@@ -236,26 +236,30 @@ fn main() {
                 assert!(txs_processed < bank.transaction_count());
                 txs_processed = bank.transaction_count();
                 tx_total += duration_as_us(&now.elapsed());
-                let mut new_bank_time = Measure::start("new_bank");
-                new_bank_time.stop();
-                let mut insert_time = Measure::start("insert_time");
-                insert_time.stop();
+
                 let mut poh_time = Measure::start("poh_time");
                 poh_recorder.lock().unwrap().reset(
                     bank.last_blockhash(),
                     bank.slot(),
                     Some((bank.slot(), bank.slot() + 1)),
                 );
+                poh_time.stop();
+
+                let mut new_bank_time = Measure::start("new_bank");
                 let new_bank = Bank::new_from_parent(&bank, &collector, bank.slot() + 1);
+                new_bank_time.stop();
+
+                let mut insert_time = Measure::start("insert_time");
                 bank_forks.insert(new_bank);
                 bank = bank_forks.working_bank();
+                insert_time.stop();
+
                 poh_recorder.lock().unwrap().set_bank(&bank);
                 assert!(poh_recorder.lock().unwrap().bank().is_some());
                 if bank.slot() > 32 {
                     bank_forks.set_root(root, &None);
                     root += 1;
                 }
-                poh_time.stop();
                 debug!(
                     "new_bank_time: {}us insert_time: {}us poh_time: {}us",
                     new_bank_time.as_us(),

core/src/snapshot_utils.rs

@@ -212,6 +212,12 @@ pub fn bank_from_archive<P: AsRef<Path>>(
     let snapshot_paths = get_snapshot_paths(&unpacked_snapshots_dir);
     let bank = rebuild_bank_from_snapshots(account_paths, &snapshot_paths, unpacked_accounts_dir)?;
 
+    if !bank.verify_hash_internal_state() {
+        warn!("Invalid snapshot hash value!");
+    } else {
+        info!("Snapshot hash value matches.");
+    }
+
     // Move the unpacked snapshots into `snapshot_config.snapshot_path`
     let dir_files = fs::read_dir(&unpacked_snapshots_dir).unwrap_or_else(|err| {
         panic!(

runtime/benches/append_vec.rs

@@ -4,6 +4,7 @@ extern crate test;
 use rand::{thread_rng, Rng};
 use solana_runtime::append_vec::test_utils::{create_test_account, get_append_vec_path};
 use solana_runtime::append_vec::AppendVec;
+use solana_sdk::hash::Hash;
 use std::sync::{Arc, Mutex};
 use std::thread::sleep;
 use std::thread::spawn;
@@ -16,7 +17,10 @@ fn append_vec_append(bencher: &mut Bencher) {
     let vec = AppendVec::new(&path.path, true, 64 * 1024);
     bencher.iter(|| {
         let (meta, account) = create_test_account(0);
-        if vec.append_account(meta, &account).is_none() {
+        if vec
+            .append_account(meta, &account, Hash::default())
+            .is_none()
+        {
             vec.reset();
         }
     });
@@ -27,7 +31,8 @@ fn add_test_accounts(vec: &AppendVec, size: usize) -> Vec<(usize, usize)> {
         .into_iter()
         .filter_map(|sample| {
             let (meta, account) = create_test_account(sample);
-            vec.append_account(meta, &account).map(|pos| (sample, pos))
+            vec.append_account(meta, &account, Hash::default())
+                .map(|pos| (sample, pos))
         })
         .collect()
 }
@@ -71,7 +76,7 @@ fn append_vec_concurrent_append_read(bencher: &mut Bencher) {
     spawn(move || loop {
         let sample = indexes1.lock().unwrap().len();
         let (meta, account) = create_test_account(sample);
-        if let Some(pos) = vec1.append_account(meta, &account) {
+        if let Some(pos) = vec1.append_account(meta, &account, Hash::default()) {
             indexes1.lock().unwrap().push((sample, pos))
         } else {
             break;
@@ -116,7 +121,7 @@ fn append_vec_concurrent_read_append(bencher: &mut Bencher) {
     bencher.iter(|| {
         let sample: usize = thread_rng().gen_range(0, 256);
         let (meta, account) = create_test_account(sample);
-        if let Some(pos) = vec.append_account(meta, &account) {
+        if let Some(pos) = vec.append_account(meta, &account, Hash::default()) {
             indexes.lock().unwrap().push((sample, pos))
         }
     });

runtime/src/accounts.rs

@@ -4,17 +4,15 @@ use crate::append_vec::StoredAccount;
 use crate::blockhash_queue::BlockhashQueue;
 use crate::message_processor::has_duplicates;
 use crate::rent_collector::RentCollector;
-use bincode::serialize;
 use log::*;
 use rayon::slice::ParallelSliceMut;
 use solana_metrics::inc_new_counter_error;
 use solana_sdk::account::Account;
-use solana_sdk::hash::{Hash, Hasher};
+use solana_sdk::bank_hash::BankHash;
 use solana_sdk::message::Message;
 use solana_sdk::native_loader;
 use solana_sdk::pubkey::Pubkey;
 use solana_sdk::system_program;
-use solana_sdk::sysvar;
 use solana_sdk::transaction::Result;
 use solana_sdk::transaction::{Transaction, TransactionError};
 use std::collections::{HashMap, HashSet};
@@ -69,8 +67,9 @@ impl Accounts {
             credit_only_account_locks: Arc::new(RwLock::new(Some(HashMap::new()))),
         }
     }
-    pub fn new_from_parent(parent: &Accounts) -> Self {
+    pub fn new_from_parent(parent: &Accounts, slot: Fork, parent_slot: Fork) -> Self {
         let accounts_db = parent.accounts_db.clone();
+        accounts_db.set_hash(slot, parent_slot);
         Accounts {
             accounts_db,
             account_locks: Mutex::new(HashSet::new()),
@@ -317,6 +316,10 @@ impl Accounts {
         })
     }
 
+    pub fn verify_hash_internal_state(&self, fork: Fork, ancestors: &HashMap<Fork, usize>) -> bool {
+        self.accounts_db.verify_hash_internal_state(fork, ancestors)
+    }
+
     pub fn load_by_program(
         &self,
         ancestors: &HashMap<Fork, usize>,
@@ -450,30 +453,13 @@ impl Accounts {
         }
     }
 
-    fn hash_account(stored_account: &StoredAccount) -> Hash {
-        let mut hasher = Hasher::default();
-        hasher.hash(&serialize(&stored_account.balance).unwrap());
-        hasher.hash(stored_account.data);
-        hasher.result()
-    }
-
-    pub fn hash_internal_state(&self, fork_id: Fork) -> Option<Hash> {
-        let account_hashes = self.scan_fork(fork_id, |stored_account| {
-            if !sysvar::check_id(&stored_account.balance.owner) {
-                Some(Self::hash_account(stored_account))
-            } else {
-                None
-            }
-        });
-
-        if account_hashes.is_empty() {
-            None
+    pub fn hash_internal_state(&self, fork_id: Fork) -> Option<BankHash> {
+        let fork_hashes = self.accounts_db.fork_hashes.read().unwrap();
+        let fork_hash = fork_hashes.get(&fork_id)?;
+        if fork_hash.0 {
+            Some(fork_hash.1)
         } else {
-            let mut hasher = Hasher::default();
-            for hash in account_hashes {
-                hasher.hash(hash.as_ref());
-            }
-            Some(hasher.result())
+            None
         }
     }