Bump rand to 0.8, rand_chacha to 0.3, getrandom to 0.2

Cargo.toml

@@ -197,7 +197,7 @@ futures-util = "0.3.28"
 gag = "1.0.0"
 generic-array = { version = "0.14.7", default-features = false }
 gethostname = "0.2.3"
-getrandom = "0.1.14"
+getrandom = "0.2.10"
 goauth = "0.13.1"
 hex = "0.4.3"
 hidapi = { version = "2.4.1", default-features = false }
@@ -263,8 +263,8 @@ qualifier_attr = { version = "0.2.2", default-features = false }
 quinn = "0.10.2"
 quinn-proto = "0.10.2"
 quote = "1.0"
-rand = "0.7.0"
-rand_chacha = "0.2.2"
+rand = "0.8.5"
+rand_chacha = "0.3.1"
 rand_core = "0.6.4"
 raptorq = "1.7.0"
 rayon = "1.7.0"

accounts-cluster-bench/src/main.rs

@@ -136,7 +136,7 @@ fn make_create_message(
     maybe_space: Option<u64>,
     mint: Option<Pubkey>,
 ) -> Message {
-    let space = maybe_space.unwrap_or_else(|| thread_rng().gen_range(0, 1000));
+    let space = maybe_space.unwrap_or_else(|| thread_rng().gen_range(0..1000));
 
     let instructions: Vec<_> = (0..num_instructions)
         .flat_map(|_| {

accounts-db/src/accounts_db.rs

@@ -4500,7 +4500,7 @@ impl AccountsDb {
             } else {
                 false
             };
-            if is_candidate || (can_randomly_shrink && thread_rng().gen_range(0, 10000) == 0) {
+            if is_candidate || (can_randomly_shrink && thread_rng().gen_range(0..10000) == 0) {
                 // we are a candidate for shrink, so either append us to the previous append vec
                 // or recreate us as a new append vec and eliminate the dead accounts
                 info!(
@@ -5712,7 +5712,7 @@ impl AccountsDb {
         self.stats
             .create_store_count
             .fetch_add(1, Ordering::Relaxed);
-        let path_index = thread_rng().gen_range(0, paths.len());
+        let path_index = thread_rng().gen_range(0..paths.len());
         let store = Arc::new(self.new_storage_entry(
             slot,
             Path::new(&paths[path_index]),
@@ -9680,7 +9680,7 @@ impl AccountsDb {
     pub fn check_accounts(&self, pubkeys: &[Pubkey], slot: Slot, num: usize, count: usize) {
         let ancestors = vec![(slot, 0)].into_iter().collect();
         for _ in 0..num {
-            let idx = thread_rng().gen_range(0, num);
+            let idx = thread_rng().gen_range(0..num);
             let account = self.load_without_fixed_root(&ancestors, &pubkeys[idx]);
             let account1 = Some((
                 AccountSharedData::new(
@@ -9887,7 +9887,7 @@ pub mod test_utils {
     // accounts cache!
     pub fn update_accounts_bench(accounts: &Accounts, pubkeys: &[Pubkey], slot: u64) {
         for pubkey in pubkeys {
-            let amount = thread_rng().gen_range(0, 10);
+            let amount = thread_rng().gen_range(0..10);
             let account = AccountSharedData::new(amount, 0, AccountSharedData::default().owner());
             accounts.store_slow_uncached(slot, pubkey, &account);
         }
@@ -11389,7 +11389,7 @@ pub mod tests {
         let mut pubkeys: Vec<Pubkey> = vec![];
         db.create_account(&mut pubkeys, 0, 100, 0, 0);
         for _ in 1..100 {
-            let idx = thread_rng().gen_range(0, 99);
+            let idx = thread_rng().gen_range(0..99);
             let ancestors = vec![(0, 0)].into_iter().collect();
             let account = db
                 .load_without_fixed_root(&ancestors, &pubkeys[idx])
@@ -11405,7 +11405,7 @@ pub mod tests {
 
         // check that all the accounts appear with a new root
         for _ in 1..100 {
-            let idx = thread_rng().gen_range(0, 99);
+            let idx = thread_rng().gen_range(0..99);
             let ancestors = vec![(0, 0)].into_iter().collect();
             let account0 = db
                 .load_without_fixed_root(&ancestors, &pubkeys[idx])
@@ -11540,7 +11540,7 @@ pub mod tests {
 
     fn update_accounts(accounts: &AccountsDb, pubkeys: &[Pubkey], slot: Slot, range: usize) {
         for _ in 1..1000 {
-            let idx = thread_rng().gen_range(0, range);
+            let idx = thread_rng().gen_range(0..range);
             let ancestors = vec![(slot, 0)].into_iter().collect();
             if let Some((mut account, _)) =
                 accounts.load_without_fixed_root(&ancestors, &pubkeys[idx])
@@ -12377,7 +12377,7 @@ pub mod tests {
                         let mut account = AccountSharedData::new(1, 0, &pubkey);
                         let mut i = 0;
                         loop {
-                            let account_bal = thread_rng().gen_range(1, 99);
+                            let account_bal = thread_rng().gen_range(1..99);
                             account.set_lamports(account_bal);
                             db.store_for_tests(slot, &[(&pubkey, &account)]);
 
@@ -15178,7 +15178,7 @@ pub mod tests {
                     // Ordering::Relaxed is ok because of no data dependencies; the modified field is
                     // completely free-standing cfg(test) control-flow knob.
                     db.load_limit
-                        .store(thread_rng().gen_range(0, 10) as u64, Ordering::Relaxed);
+                        .store(thread_rng().gen_range(0..10) as u64, Ordering::Relaxed);
 
                     // Load should never be unable to find this key
                     let loaded_account = db

accounts-db/src/accounts_index.rs

@@ -1619,7 +1619,7 @@ impl<T: IndexValue, U: DiskIndexValue + From<T> + Into<T>> AccountsIndex<T, U> {
         let expected_items_per_bin = item_len * 2 / bins;
         // offset bin 0 in the 'binned' array by a random amount.
         // This results in calls to insert_new_entry_if_missing_with_lock from different threads starting at different bins.
-        let random_offset = thread_rng().gen_range(0, bins);
+        let random_offset = thread_rng().gen_range(0..bins);
         let use_disk = self.storage.storage.disk.is_some();
         let mut binned = (0..bins)
             .map(|mut pubkey_bin| {

accounts-db/src/ancient_append_vecs.rs

@@ -91,7 +91,7 @@ impl AncientSlotInfos {
             let should_shrink = if capacity > 0 {
                 let alive_ratio = alive_bytes * 100 / capacity;
                 alive_ratio < 90
-                    || if can_randomly_shrink && thread_rng().gen_range(0, 10000) == 0 {
+                    || if can_randomly_shrink && thread_rng().gen_range(0..10000) == 0 {
                         was_randomly_shrunk = true;
                         true
                     } else {
@@ -1202,7 +1202,7 @@ pub mod tests {
                 let mut data_size = 450;
                 // random # of extra accounts here
                 let total_accounts_per_storage =
-                    thread_rng().gen_range(0, total_accounts_per_storage);
+                    thread_rng().gen_range(0..total_accounts_per_storage);
                 let _pubkeys_and_accounts = storages
                     .iter()
                     .map(|storage| {

accounts-db/src/append_vec.rs

@@ -1067,7 +1067,7 @@ pub mod tests {
 
         let now = Instant::now();
         for _ in 0..size {
-            let sample = thread_rng().gen_range(0, indexes.len());
+            let sample = thread_rng().gen_range(0..indexes.len());
             let account = create_test_account(sample);
             assert_eq!(av.get_account_test(indexes[sample]).unwrap(), account);
         }

accounts-db/src/append_vec/test_utils.rs

@@ -25,6 +25,7 @@ pub fn get_append_vec_path(path: &str) -> TempFile {
     let out_dir = get_append_vec_dir();
     let rand_string: String = rand::thread_rng()
         .sample_iter(&Alphanumeric)
+        .map(char::from)
         .take(30)
         .collect();
     let dir = format!("{out_dir}/{rand_string}");

accounts-db/src/cache_hash_data.rs

@@ -462,7 +462,7 @@ pub mod tests {
                                 }
 
                                 CalculateHashIntermediate::new(
-                                    solana_sdk::hash::new_rand(&mut rng),
+                                    solana_sdk::hash::Hash::new_unique(),
                                     ct as u64,
                                     pk,
                                 )

accounts-db/src/hardened_unpack.rs

@@ -381,7 +381,7 @@ where
                 };
                 if let ["accounts", file] = parts {
                     // Randomly distribute the accounts files about the available `account_paths`,
-                    let path_index = thread_rng().gen_range(0, account_paths.len());
+                    let path_index = thread_rng().gen_range(0..account_paths.len());
                     match account_paths
                         .get(path_index)
                         .map(|path_buf| path_buf.as_path())

accounts-db/src/in_mem_accounts_index.rs

@@ -179,7 +179,7 @@ impl<T: IndexValue, U: DiskIndexValue + From<T> + Into<T>> InMemAccountsIndex<T,
             // Spread out the scanning across all ages within the window.
             // This causes us to scan 1/N of the bins each 'Age'
             remaining_ages_to_skip_flushing: AtomicU8::new(
-                thread_rng().gen_range(0, num_ages_to_distribute_flushes),
+                thread_rng().gen_range(0..num_ages_to_distribute_flushes),
             ),
             num_ages_to_distribute_flushes,
         }
@@ -932,7 +932,7 @@ impl<T: IndexValue, U: DiskIndexValue + From<T> + Into<T>> InMemAccountsIndex<T,
         // random eviction
         const N: usize = 1000;
         // 1/N chance of eviction
-        thread_rng().gen_range(0, N) == 0
+        thread_rng().gen_range(0..N) == 0
     }
 
     /// assumes 1 entry in the slot list. Ignores overhead of the HashMap and such

accounts-db/src/read_only_accounts_cache.rs

@@ -291,7 +291,7 @@ mod tests {
         const MAX_CACHE_SIZE: usize = 17 * (CACHE_ENTRY_SIZE + DATA_SIZE);
         let mut rng = ChaChaRng::from_seed(SEED);
         let cache = ReadOnlyAccountsCache::new(MAX_CACHE_SIZE);
-        let slots: Vec<Slot> = repeat_with(|| rng.gen_range(0, 1000)).take(5).collect();
+        let slots: Vec<Slot> = repeat_with(|| rng.gen_range(0..1000)).take(5).collect();
         let pubkeys: Vec<Pubkey> = repeat_with(|| {
             let mut arr = [0u8; 32];
             rng.fill(&mut arr[..]);

accounts-db/src/stake_rewards.rs

@@ -98,7 +98,7 @@ impl StakeReward {
             stake_pubkey: Pubkey::new_unique(),
             stake_reward_info: RewardInfo {
                 reward_type: RewardType::Staking,
-                lamports: rng.gen_range(1, 200),
+                lamports: rng.gen_range(1..200),
                 post_balance: 0,  /* unused atm */
                 commission: None, /* unused atm */
             },

accounts-db/src/tiered_storage/index.rs

@@ -127,7 +127,7 @@ mod tests {
             .iter()
             .map(|address| AccountIndexWriterEntry {
                 address,
-                block_offset: rng.gen_range(128, 2048),
+                block_offset: rng.gen_range(128..2048),
                 intra_block_offset: 0,
             })
             .collect();

bloom/benches/bloom.rs

@@ -103,7 +103,7 @@ fn bench_sigs_hashmap(bencher: &mut Bencher) {
 #[bench]
 fn bench_add_hash(bencher: &mut Bencher) {
     let mut rng = rand::thread_rng();
-    let hash_values: Vec<_> = std::iter::repeat_with(|| solana_sdk::hash::new_rand(&mut rng))
+    let hash_values: Vec<_> = std::iter::repeat_with(Hash::new_unique)
         .take(1200)
         .collect();
     let mut fail = 0;
@@ -112,7 +112,7 @@ fn bench_add_hash(bencher: &mut Bencher) {
         for hash_value in &hash_values {
             bloom.add(hash_value);
         }
-        let index = rng.gen_range(0, hash_values.len());
+        let index = rng.gen_range(0..hash_values.len());
         if !bloom.contains(&hash_values[index]) {
             fail += 1;
         }
@@ -123,7 +123,7 @@ fn bench_add_hash(bencher: &mut Bencher) {
 #[bench]
 fn bench_add_hash_atomic(bencher: &mut Bencher) {
     let mut rng = rand::thread_rng();
-    let hash_values: Vec<_> = std::iter::repeat_with(|| solana_sdk::hash::new_rand(&mut rng))
+    let hash_values: Vec<_> = std::iter::repeat_with(Hash::new_unique)
         .take(1200)
         .collect();
     let mut fail = 0;
@@ -136,7 +136,7 @@ fn bench_add_hash_atomic(bencher: &mut Bencher) {
         for hash_value in &hash_values {
             bloom.add(hash_value);
         }
-        let index = rng.gen_range(0, hash_values.len());
+        let index = rng.gen_range(0..hash_values.len());
         if !bloom.contains(&hash_values[index]) {
             fail += 1;
         }

bloom/src/bloom.rs

@@ -308,10 +308,16 @@ mod test {
         );
     }
 
+    fn generate_random_hash() -> Hash {
+        let mut rng = rand::thread_rng();
+        let mut hash = [0u8; solana_sdk::hash::HASH_BYTES];
+        rng.fill(&mut hash);
+        Hash::new_from_array(hash)
+    }
+
     #[test]
     fn test_atomic_bloom() {
-        let mut rng = rand::thread_rng();
-        let hash_values: Vec<_> = std::iter::repeat_with(|| solana_sdk::hash::new_rand(&mut rng))
+        let hash_values: Vec<_> = std::iter::repeat_with(generate_random_hash)
             .take(1200)
             .collect();
         let bloom: AtomicBloom<_> = Bloom::<Hash>::random(1287, 0.1, 7424).into();
@@ -328,7 +334,7 @@ mod test {
         for hash_value in hash_values {
             assert!(bloom.contains(&hash_value));
         }
-        let false_positive = std::iter::repeat_with(|| solana_sdk::hash::new_rand(&mut rng))
+        let false_positive = std::iter::repeat_with(generate_random_hash)
             .take(10_000)
             .filter(|hash_value| bloom.contains(hash_value))
             .count();
@@ -340,7 +346,7 @@ mod test {
         let mut rng = rand::thread_rng();
         let keys: Vec<_> = std::iter::repeat_with(|| rng.gen()).take(5).collect();
         let mut bloom = Bloom::<Hash>::new(9731, keys.clone());
-        let hash_values: Vec<_> = std::iter::repeat_with(|| solana_sdk::hash::new_rand(&mut rng))
+        let hash_values: Vec<_> = std::iter::repeat_with(generate_random_hash)
             .take(1000)
             .collect();
         for hash_value in &hash_values {
@@ -375,10 +381,9 @@ mod test {
             assert!(bloom.contains(hash_value));
         }
         // Round trip, inserting new hash values.
-        let more_hash_values: Vec<_> =
-            std::iter::repeat_with(|| solana_sdk::hash::new_rand(&mut rng))
-                .take(1000)
-                .collect();
+        let more_hash_values: Vec<_> = std::iter::repeat_with(generate_random_hash)
+            .take(1000)
+            .collect();
         let bloom: AtomicBloom<_> = bloom.into();
         assert_eq!(bloom.num_bits, 9731);
         assert_eq!(bloom.bits.len(), (9731 + 63) / 64);
@@ -391,7 +396,7 @@ mod test {
         for hash_value in &more_hash_values {
             assert!(bloom.contains(hash_value));
         }
-        let false_positive = std::iter::repeat_with(|| solana_sdk::hash::new_rand(&mut rng))
+        let false_positive = std::iter::repeat_with(generate_random_hash)
             .take(10_000)
             .filter(|hash_value| bloom.contains(hash_value))
             .count();
@@ -410,7 +415,7 @@ mod test {
         for hash_value in &more_hash_values {
             assert!(bloom.contains(hash_value));
         }
-        let false_positive = std::iter::repeat_with(|| solana_sdk::hash::new_rand(&mut rng))
+        let false_positive = std::iter::repeat_with(generate_random_hash)
             .take(10_000)
             .filter(|hash_value| bloom.contains(hash_value))
             .count();

bucket_map/src/bucket.rs

@@ -483,7 +483,7 @@ impl<'b, T: Clone + Copy + 'static> Bucket<T> {
         let best_bucket = &mut self.data[best_fit_bucket as usize];
         let cap_power = best_bucket.contents.capacity_pow2();
         let cap = best_bucket.capacity();
-        let pos = thread_rng().gen_range(0, cap);
+        let pos = thread_rng().gen_range(0..cap);
         let mut success = false;
         // max search is increased here by a lot for this search. The idea is that we just have to find an empty bucket somewhere.
         // We don't mind waiting on a new write (by searching longer). Writing is done in the background only.