diff --git a/merkle-root-bench/src/main.rs b/merkle-root-bench/src/main.rs index 26b4d8ffc3..5e15a677c8 100644 --- a/merkle-root-bench/src/main.rs +++ b/merkle-root-bench/src/main.rs @@ -2,7 +2,7 @@ extern crate log; use { clap::{crate_description, crate_name, value_t, App, Arg}, solana_measure::measure::Measure, - solana_runtime::accounts_hash::AccountsHash, + solana_runtime::accounts_hash::AccountsHasher, solana_sdk::{hash::Hash, pubkey::Pubkey}, }; @@ -38,7 +38,7 @@ fn main() { let hashes = hashes.clone(); // done outside timing let mut time = Measure::start("compute_merkle_root"); let fanout = 16; - AccountsHash::compute_merkle_root(hashes, fanout); + AccountsHasher::compute_merkle_root(hashes, fanout); time.stop(); time.as_us() }) diff --git a/runtime/src/accounts_db.rs b/runtime/src/accounts_db.rs index c8d9247cf0..d92927f0de 100644 --- a/runtime/src/accounts_db.rs +++ b/runtime/src/accounts_db.rs @@ -24,7 +24,7 @@ use { accounts_background_service::{DroppedSlotsSender, SendDroppedBankCallback}, accounts_cache::{AccountsCache, CachedAccount, SlotCache}, accounts_hash::{ - AccountsHash, CalcAccountsHashConfig, CalculateHashIntermediate, HashStats, + AccountsHasher, CalcAccountsHashConfig, CalculateHashIntermediate, HashStats, PreviousPass, }, accounts_index::{ @@ -6921,11 +6921,11 @@ impl AccountsDb { pub fn checked_iterative_sum_for_capitalization(total_cap: u64, new_cap: u64) -> u64 { let new_total = total_cap as u128 + new_cap as u128; - AccountsHash::checked_cast_for_capitalization(new_total) + AccountsHasher::checked_cast_for_capitalization(new_total) } pub fn checked_sum_for_capitalization>(balances: T) -> u64 { - AccountsHash::checked_cast_for_capitalization(balances.map(|b| b as u128).sum::()) + AccountsHasher::checked_cast_for_capitalization(balances.map(|b| b as u128).sum::()) } pub fn calculate_accounts_hash_from_index( @@ -7014,7 +7014,7 @@ impl AccountsDb { .collect(); let mut total = total_lamports.lock().unwrap(); *total = - AccountsHash::checked_cast_for_capitalization(*total as u128 + sum); + AccountsHasher::checked_cast_for_capitalization(*total as u128 + sum); result }).collect() }; @@ -7036,7 +7036,7 @@ impl AccountsDb { let total_lamports = *total_lamports.lock().unwrap(); let mut hash_time = Measure::start("hash"); - let (accumulated_hash, hash_total) = AccountsHash::calculate_hash(hashes); + let (accumulated_hash, hash_total) = AccountsHasher::calculate_hash(hashes); hash_time.stop(); datapoint_info!( "calculate_accounts_hash_from_index", @@ -7576,7 +7576,7 @@ impl AccountsDb { let mut sort_time = Measure::start("sort"); { // sort_by vs unstable because slot and write_version are already in order - items.sort_by(AccountsHash::compare_two_hash_entries); + items.sort_by(AccountsHasher::compare_two_hash_entries); } sort_time.stop(); time.fetch_add(sort_time.as_us(), Ordering::Relaxed); @@ -7646,7 +7646,7 @@ impl AccountsDb { end: (pass + 1) * bins_per_pass, }; - let hash = AccountsHash { + let hash = AccountsHasher { filler_account_suffix: if self.filler_accounts_config.count > 0 { self.filler_account_suffix } else { @@ -7672,7 +7672,7 @@ impl AccountsDb { .collect::>(); // rework slices of data into bins for parallel processing and to match data shape expected by 'rest_of_hash_calculation' - let result = AccountsHash::get_binned_data( + let result = AccountsHasher::get_binned_data( &slices, PUBKEY_BINS_FOR_CALCULATING_HASHES, &bounds, @@ -7885,7 +7885,7 @@ impl AccountsDb { self.extend_hashes_with_skipped_rewrites(&mut hashes, skipped_rewrites); - let ret = AccountsHash::accumulate_account_hashes(hashes); + let ret = AccountsHasher::accumulate_account_hashes(hashes); accumulate.stop(); let mut uncleaned_time = Measure::start("uncleaned_index"); self.uncleaned_pubkeys.insert(slot, dirty_keys); @@ -7922,7 +7922,7 @@ impl AccountsDb { if self.filler_accounts_enabled() { // simulate the time we would normally spend hashing the filler accounts // this is an over approximation but at least takes a stab at simulating what the validator would spend time doing - let _ = AccountsHash::accumulate_account_hashes( + let _ = AccountsHasher::accumulate_account_hashes( skipped_rewrites .iter() .map(|(k, v)| (*k, *v)) @@ -10620,7 +10620,7 @@ pub mod tests { let (storages, raw_expected) = sample_storages_and_accounts(); let expected_hash = - AccountsHash::compute_merkle_root_loop(raw_expected.clone(), MERKLE_FANOUT, |item| { + AccountsHasher::compute_merkle_root_loop(raw_expected.clone(), MERKLE_FANOUT, |item| { item.hash }); let sum = raw_expected.iter().map(|item| item.lamports).sum(); diff --git a/runtime/src/accounts_hash.rs b/runtime/src/accounts_hash.rs index 301f7a8a3f..95e199dc1d 100644 --- a/runtime/src/accounts_hash.rs +++ b/runtime/src/accounts_hash.rs @@ -398,11 +398,11 @@ impl CumulativeOffsets { } #[derive(Debug, Default)] -pub struct AccountsHash { +pub struct AccountsHasher { pub filler_account_suffix: Option, } -impl AccountsHash { +impl AccountsHasher { /// true if it is possible that there are filler accounts present pub fn filler_accounts_enabled(&self) -> bool { self.filler_account_suffix.is_some() @@ -412,7 +412,7 @@ impl AccountsHash { let cumulative_offsets = CumulativeOffsets::from_raw(&hashes); let hash_total = cumulative_offsets.total_count; - let result = AccountsHash::compute_merkle_root_from_slices( + let result = AccountsHasher::compute_merkle_root_from_slices( hash_total, MERKLE_FANOUT, None, @@ -1081,17 +1081,17 @@ pub mod tests { #[test] fn test_accountsdb_div_ceil() { - assert_eq!(AccountsHash::div_ceil(10, 3), 4); - assert_eq!(AccountsHash::div_ceil(0, 1), 0); - assert_eq!(AccountsHash::div_ceil(0, 5), 0); - assert_eq!(AccountsHash::div_ceil(9, 3), 3); - assert_eq!(AccountsHash::div_ceil(9, 9), 1); + assert_eq!(AccountsHasher::div_ceil(10, 3), 4); + assert_eq!(AccountsHasher::div_ceil(0, 1), 0); + assert_eq!(AccountsHasher::div_ceil(0, 5), 0); + assert_eq!(AccountsHasher::div_ceil(9, 3), 3); + assert_eq!(AccountsHasher::div_ceil(9, 9), 1); } #[test] #[should_panic(expected = "attempt to divide by zero")] fn test_accountsdb_div_ceil_fail() { - assert_eq!(AccountsHash::div_ceil(10, 0), 0); + assert_eq!(AccountsHasher::div_ceil(10, 0), 0); } fn for_rest(original: &[CalculateHashIntermediate]) -> Vec> { @@ -1115,7 +1115,7 @@ pub mod tests { let val = CalculateHashIntermediate::new(hash, 0, key); account_maps.push(val); - let accounts_hash = AccountsHash::default(); + let accounts_hash = AccountsHasher::default(); let result = accounts_hash.rest_of_hash_calculation( for_rest(&account_maps), &mut HashStats::default(), @@ -1197,7 +1197,7 @@ pub mod tests { let mut previous_pass = PreviousPass::default(); - let accounts_index = AccountsHash::default(); + let accounts_index = AccountsHasher::default(); if pass == 0 { // first pass that is not last and is empty let result = accounts_index.rest_of_hash_calculation( @@ -1232,7 +1232,7 @@ pub mod tests { let expected_hash = Hash::from_str("8j9ARGFv4W2GfML7d3sVJK2MePwrikqYnu6yqer28cCa").unwrap(); - let accounts_index = AccountsHash::default(); + let accounts_index = AccountsHasher::default(); if pass == 2 { let result = accounts_index.rest_of_hash_calculation( empty_data(), @@ -1280,7 +1280,7 @@ pub mod tests { let hash = Hash::new(&[2u8; 32]); let val = CalculateHashIntermediate::new(hash, 20, key); account_maps.push(val); - let accounts_hash = AccountsHash::default(); + let accounts_hash = AccountsHasher::default(); let result = accounts_hash.rest_of_hash_calculation( for_rest(&[account_maps[0].clone()]), &mut HashStats::default(), @@ -1328,7 +1328,7 @@ pub mod tests { assert_eq!(previous_pass.reduced_hashes.len(), 0); assert_eq!(previous_pass.lamports, 0); - let expected_hash = AccountsHash::compute_merkle_root( + let expected_hash = AccountsHasher::compute_merkle_root( account_maps .iter() .map(|a| (a.pubkey, a.hash)) @@ -1347,7 +1347,7 @@ pub mod tests { solana_logger::setup(); let mut account_maps = Vec::new(); - let accounts_hash = AccountsHash::default(); + let accounts_hash = AccountsHasher::default(); const TARGET_FANOUT_LEVEL: usize = 3; let target_fanout = MERKLE_FANOUT.pow(TARGET_FANOUT_LEVEL as u32); @@ -1363,7 +1363,7 @@ pub mod tests { } let mut chunk = account_maps[0..plus1].to_vec(); - chunk.sort_by(AccountsHash::compare_two_hash_entries); + chunk.sort_by(AccountsHasher::compare_two_hash_entries); let sorted = chunk.clone(); // first 4097 hashes (1 left over) @@ -1381,7 +1381,7 @@ pub mod tests { let left_over_1 = sorted[plus1 - 1].hash; assert_eq!(previous_pass.remaining_unhashed, vec![left_over_1]); assert_eq!(previous_pass.reduced_hashes.len(), 1); - let expected_hash = AccountsHash::compute_merkle_root( + let expected_hash = AccountsHasher::compute_merkle_root( sorted[0..target_fanout] .iter() .map(|a| (a.pubkey, a.hash)) @@ -1398,12 +1398,12 @@ pub mod tests { ); let mut chunk = account_maps[plus1..plus1 * 2].to_vec(); - chunk.sort_by(AccountsHash::compare_two_hash_entries); + chunk.sort_by(AccountsHasher::compare_two_hash_entries); let sorted2 = chunk.clone(); let mut with_left_over = vec![left_over_1]; with_left_over.extend(sorted2[0..plus1 - 2].iter().cloned().map(|i| i.hash)); - let expected_hash2 = AccountsHash::compute_merkle_root( + let expected_hash2 = AccountsHasher::compute_merkle_root( with_left_over[0..target_fanout] .iter() .map(|a| (Pubkey::default(), *a)) @@ -1455,7 +1455,7 @@ pub mod tests { let mut combined = sorted; combined.extend(sorted2); - let expected_hash = AccountsHash::compute_merkle_root( + let expected_hash = AccountsHasher::compute_merkle_root( combined .iter() .map(|a| (a.pubkey, a.hash)) @@ -1477,7 +1477,8 @@ pub mod tests { }]]]; let temp_vec = vec.to_vec(); let slice = convert_to_slice2(&temp_vec); - let (hashes, lamports, _) = AccountsHash::default().de_dup_accounts_in_parallel(&slice, 0); + let (hashes, lamports, _) = + AccountsHasher::default().de_dup_accounts_in_parallel(&slice, 0); assert_eq!(vec![&Hash::default()], hashes); assert_eq!(lamports, 1); } @@ -1485,7 +1486,7 @@ pub mod tests { #[test] fn test_accountsdb_de_dup_accounts_empty() { solana_logger::setup(); - let accounts_hash = AccountsHash::default(); + let accounts_hash = AccountsHasher::default(); let vec = vec![vec![], vec![]]; let (hashes, lamports) = @@ -1577,7 +1578,7 @@ pub mod tests { result }).collect(); - let hash = AccountsHash::default(); + let hash = AccountsHasher::default(); let mut expected_index = 0; for last_slice in 0..2 { for start in 0..COUNT { @@ -1690,7 +1691,7 @@ pub mod tests { let val2 = CalculateHashIntermediate::new(hash2, 4, key); assert_eq!( std::cmp::Ordering::Equal, // no longer comparing slots or versions - AccountsHash::compare_two_hash_entries(&val, &val2) + AccountsHasher::compare_two_hash_entries(&val, &val2) ); // slot same, vers = @@ -1698,7 +1699,7 @@ pub mod tests { let val3 = CalculateHashIntermediate::new(hash3, 2, key); assert_eq!( std::cmp::Ordering::Equal, - AccountsHash::compare_two_hash_entries(&val, &val3) + AccountsHasher::compare_two_hash_entries(&val, &val3) ); // slot same, vers > @@ -1706,7 +1707,7 @@ pub mod tests { let val4 = CalculateHashIntermediate::new(hash4, 6, key); assert_eq!( std::cmp::Ordering::Equal, // no longer comparing slots or versions - AccountsHash::compare_two_hash_entries(&val, &val4) + AccountsHasher::compare_two_hash_entries(&val, &val4) ); // slot >, version < @@ -1714,14 +1715,14 @@ pub mod tests { let val5 = CalculateHashIntermediate::new(hash5, 8, key); assert_eq!( std::cmp::Ordering::Equal, // no longer comparing slots or versions - AccountsHash::compare_two_hash_entries(&val, &val5) + AccountsHasher::compare_two_hash_entries(&val, &val5) ); } fn test_de_dup_accounts_in_parallel<'a>( account_maps: &'a [SortedDataByPubkey<'a>], ) -> (Vec<&'a Hash>, u64, usize) { - AccountsHash::default().de_dup_accounts_in_parallel(account_maps, 0) + AccountsHasher::default().de_dup_accounts_in_parallel(account_maps, 0) } #[test] @@ -1946,7 +1947,7 @@ pub mod tests { } fn test_hashing_larger(hashes: Vec<(Pubkey, Hash)>, fanout: usize) -> Hash { - let result = AccountsHash::compute_merkle_root(hashes.clone(), fanout); + let result = AccountsHasher::compute_merkle_root(hashes.clone(), fanout); let reduced: Vec<_> = hashes.iter().map(|x| x.1).collect(); let result2 = test_hashing(reduced, fanout); assert_eq!(result, result2, "len: {}", hashes.len()); @@ -1955,9 +1956,9 @@ pub mod tests { fn test_hashing(hashes: Vec, fanout: usize) -> Hash { let temp: Vec<_> = hashes.iter().map(|h| (Pubkey::default(), *h)).collect(); - let result = AccountsHash::compute_merkle_root(temp, fanout); + let result = AccountsHasher::compute_merkle_root(temp, fanout); let reduced: Vec<_> = hashes.clone(); - let result2 = AccountsHash::compute_merkle_root_from_slices( + let result2 = AccountsHasher::compute_merkle_root_from_slices( hashes.len(), fanout, None, @@ -1966,7 +1967,7 @@ pub mod tests { ); assert_eq!(result, result2.0, "len: {}", hashes.len()); - let result2 = AccountsHash::compute_merkle_root_from_slices( + let result2 = AccountsHasher::compute_merkle_root_from_slices( hashes.len(), fanout, Some(1), @@ -1985,7 +1986,7 @@ pub mod tests { let offsets = CumulativeOffsets::from_raw_2d(&src); let get_slice = |start: usize| -> &[Hash] { offsets.get_slice(&src, start) }; - let result2 = AccountsHash::compute_merkle_root_from_slices( + let result2 = AccountsHasher::compute_merkle_root_from_slices( offsets.total_count, fanout, None, @@ -2078,11 +2079,11 @@ pub mod tests { test_hashing_larger(input.clone(), fanout) } else { // this sorts inside - let early_result = AccountsHash::accumulate_account_hashes( + let early_result = AccountsHasher::accumulate_account_hashes( input.iter().map(|i| (i.0, i.1)).collect::>(), ); - AccountsHash::sort_hashes_by_pubkey(&mut input); - let result = AccountsHash::compute_merkle_root(input.clone(), fanout); + AccountsHasher::sort_hashes_by_pubkey(&mut input); + let result = AccountsHasher::compute_merkle_root(input.clone(), fanout); assert_eq!(early_result, result); result }; @@ -2115,7 +2116,7 @@ pub mod tests { ), CalculateHashIntermediate::new(Hash::new(&[2u8; 32]), offset + 1, Pubkey::new_unique()), ]; - AccountsHash::default().de_dup_accounts_in_parallel(&[convert_to_slice(&[input])], 0); + AccountsHasher::default().de_dup_accounts_in_parallel(&[convert_to_slice(&[input])], 0); } fn convert_to_slice( @@ -2151,7 +2152,7 @@ pub mod tests { Pubkey::new_unique(), )], ]; - AccountsHash::default().de_dup_and_eliminate_zeros( + AccountsHasher::default().de_dup_and_eliminate_zeros( &[convert_to_slice(&input)], &mut HashStats::default(), 2, // accounts above are in 2 groups @@ -2167,10 +2168,10 @@ pub mod tests { )]; let data2 = vec![&data[..]]; let bins = 1; - let result = AccountsHash::get_binned_data(&data2, bins, &(0..bins)); + let result = AccountsHasher::get_binned_data(&data2, bins, &(0..bins)); assert_eq!(result, vec![vec![&data[..]]]); let bins = 2; - let result = AccountsHash::get_binned_data(&data2, bins, &(0..bins)); + let result = AccountsHasher::get_binned_data(&data2, bins, &(0..bins)); assert_eq!(result, vec![vec![&data[..], &data[0..0]]]); let data = [CalculateHashIntermediate::new( Hash::default(), @@ -2178,21 +2179,21 @@ pub mod tests { Pubkey::new(&[255u8; 32]), )]; let data2 = vec![&data[..]]; - let result = AccountsHash::get_binned_data(&data2, bins, &(0..bins)); + let result = AccountsHasher::get_binned_data(&data2, bins, &(0..bins)); assert_eq!(result, vec![vec![&data[0..0], &data[..]]]); let data = [ CalculateHashIntermediate::new(Hash::default(), 1, Pubkey::new(&[254u8; 32])), CalculateHashIntermediate::new(Hash::default(), 1, Pubkey::new(&[255u8; 32])), ]; let data2 = vec![&data[..]]; - let result = AccountsHash::get_binned_data(&data2, bins, &(0..bins)); + let result = AccountsHasher::get_binned_data(&data2, bins, &(0..bins)); assert_eq!(result, vec![vec![&data[0..0], &data[..]]]); let data = [ CalculateHashIntermediate::new(Hash::default(), 1, Pubkey::new(&[1u8; 32])), CalculateHashIntermediate::new(Hash::default(), 1, Pubkey::new(&[255u8; 32])), ]; let data2 = vec![&data[..]]; - let result = AccountsHash::get_binned_data(&data2, bins, &(0..bins)); + let result = AccountsHasher::get_binned_data(&data2, bins, &(0..bins)); assert_eq!(result, vec![vec![&data[0..1], &data[1..2]]]); } }