From 283a2b15402867baeb0735acda1cdc8632afd400 Mon Sep 17 00:00:00 2001 From: behzad nouri Date: Fri, 6 Jan 2023 17:32:26 +0000 Subject: [PATCH] removes #[allow(clippy::same_item_push)] (#29543) --- core/benches/banking_stage.rs | 19 ++++------ core/benches/retransmit_stage.rs | 11 +++--- core/src/broadcast_stage.rs | 53 ++++++++++++++------------- entry/src/entry.rs | 25 +++++-------- gossip/src/cluster_info.rs | 14 ++++--- gossip/src/epoch_slots.rs | 37 ++++++++----------- ledger/src/blockstore.rs | 15 ++++---- transaction-status/src/parse_stake.rs | 7 +--- transaction-status/src/parse_token.rs | 11 +----- 9 files changed, 83 insertions(+), 109 deletions(-) diff --git a/core/benches/banking_stage.rs b/core/benches/banking_stage.rs index e537b67848..cab828f623 100644 --- a/core/benches/banking_stage.rs +++ b/core/benches/banking_stage.rs @@ -42,6 +42,7 @@ use { vote_state::VoteStateUpdate, vote_transaction::new_vote_state_update_transaction, }, std::{ + iter::repeat_with, sync::{atomic::Ordering, Arc, RwLock}, time::{Duration, Instant}, }, @@ -128,17 +129,17 @@ fn make_accounts_txs(txes: usize, mint_keypair: &Keypair, hash: Hash) -> Vec Vec { let progs = 4; (0..txes) .map(|_| { - let mut instructions = vec![]; let from_key = Keypair::new(); - for _ in 1..progs { + let instructions: Vec<_> = repeat_with(|| { let to_key = pubkey::new_rand(); - instructions.push(system_instruction::transfer(&from_key.pubkey(), &to_key, 1)); - } + system_instruction::transfer(&from_key.pubkey(), &to_key, 1) + }) + .take(progs) + .collect(); let message = Message::new(&instructions, Some(&from_key.pubkey())); Transaction::new(&[&from_key], message, hash) }) @@ -400,7 +401,6 @@ fn simulate_process_entries( process_entries_for_tests(&bank, vec![entry], randomize_txs, None, None).unwrap(); } -#[allow(clippy::same_item_push)] fn bench_process_entries(randomize_txs: bool, bencher: &mut Bencher) { // entropy multiplier should be big enough to provide sufficient entropy // but small enough to not take too much time while executing the test. @@ -416,14 +416,9 @@ fn bench_process_entries(randomize_txs: bool, bencher: &mut Bencher) { .. } = create_genesis_config((num_accounts + 1) as u64 * initial_lamports); - let mut keypairs: Vec = vec![]; + let keypairs: Vec = repeat_with(Keypair::new).take(num_accounts).collect(); let tx_vector: Vec = Vec::with_capacity(num_accounts / 2); - for _ in 0..num_accounts { - let keypair = Keypair::new(); - keypairs.push(keypair); - } - bencher.iter(|| { simulate_process_entries( randomize_txs, diff --git a/core/benches/retransmit_stage.rs b/core/benches/retransmit_stage.rs index bad02d043a..8923822956 100644 --- a/core/benches/retransmit_stage.rs +++ b/core/benches/retransmit_stage.rs @@ -28,6 +28,7 @@ use { }, solana_streamer::socket::SocketAddrSpace, std::{ + iter::repeat_with, net::UdpSocket, sync::{ atomic::{AtomicUsize, Ordering}, @@ -47,7 +48,6 @@ use { // threads loop indefinitely. #[ignore] #[bench] -#[allow(clippy::same_item_push)] fn bench_retransmitter(bencher: &mut Bencher) { solana_logger::setup(); let cluster_info = ClusterInfo::new( @@ -56,8 +56,7 @@ fn bench_retransmitter(bencher: &mut Bencher) { SocketAddrSpace::Unspecified, ); const NUM_PEERS: usize = 4; - let mut peer_sockets = Vec::new(); - for _ in 0..NUM_PEERS { + let peer_sockets: Vec<_> = repeat_with(|| { let id = Pubkey::new_unique(); let socket = UdpSocket::bind("0.0.0.0:0").unwrap(); let mut contact_info = ContactInfo::new_localhost(&id, timestamp()); @@ -67,8 +66,10 @@ fn bench_retransmitter(bencher: &mut Bencher) { info!("local: {:?}", contact_info.tvu); cluster_info.insert_info(contact_info); socket.set_nonblocking(true).unwrap(); - peer_sockets.push(socket); - } + socket + }) + .take(NUM_PEERS) + .collect(); let peer_sockets = Arc::new(peer_sockets); let cluster_info = Arc::new(cluster_info); diff --git a/core/src/broadcast_stage.rs b/core/src/broadcast_stage.rs index a42c8a6885..061b93513c 100644 --- a/core/src/broadcast_stage.rs +++ b/core/src/broadcast_stage.rs @@ -35,6 +35,7 @@ use { }, std::{ collections::{HashMap, HashSet}, + iter::repeat_with, net::UdpSocket, sync::{ atomic::{AtomicBool, Ordering}, @@ -235,7 +236,6 @@ impl BroadcastStage { /// which will then close FetchStage in the Tpu, and then the rest of the Tpu, /// completing the cycle. #[allow(clippy::too_many_arguments)] - #[allow(clippy::same_item_push)] fn new( socks: Vec, cluster_info: Arc, @@ -271,42 +271,43 @@ impl BroadcastStage { }; let mut thread_hdls = vec![thread_hdl]; let socket_receiver = Arc::new(Mutex::new(socket_receiver)); - for sock in socks.into_iter() { + thread_hdls.extend(socks.into_iter().map(|sock| { let socket_receiver = socket_receiver.clone(); let mut bs_transmit = broadcast_stage_run.clone(); let cluster_info = cluster_info.clone(); let bank_forks = bank_forks.clone(); - let t = Builder::new() + let run_transmit = move || loop { + let res = bs_transmit.transmit(&socket_receiver, &cluster_info, &sock, &bank_forks); + let res = Self::handle_error(res, "solana-broadcaster-transmit"); + if let Some(res) = res { + return res; + } + }; + Builder::new() .name("solBroadcastTx".to_string()) - .spawn(move || loop { - let res = - bs_transmit.transmit(&socket_receiver, &cluster_info, &sock, &bank_forks); - let res = Self::handle_error(res, "solana-broadcaster-transmit"); - if let Some(res) = res { - return res; - } - }) - .unwrap(); - thread_hdls.push(t); - } + .spawn(run_transmit) + .unwrap() + })); let blockstore_receiver = Arc::new(Mutex::new(blockstore_receiver)); - for _ in 0..NUM_INSERT_THREADS { - let blockstore_receiver = blockstore_receiver.clone(); - let mut bs_record = broadcast_stage_run.clone(); - let btree = blockstore.clone(); - let t = Builder::new() - .name("solBroadcastRec".to_string()) - .spawn(move || loop { + thread_hdls.extend( + repeat_with(|| { + let blockstore_receiver = blockstore_receiver.clone(); + let mut bs_record = broadcast_stage_run.clone(); + let btree = blockstore.clone(); + let run_record = move || loop { let res = bs_record.record(&blockstore_receiver, &btree); let res = Self::handle_error(res, "solana-broadcaster-record"); if let Some(res) = res { return res; } - }) - .unwrap(); - thread_hdls.push(t); - } - + }; + Builder::new() + .name("solBroadcastRec".to_string()) + .spawn(run_record) + .unwrap() + }) + .take(NUM_INSERT_THREADS), + ); let retransmit_thread = Builder::new() .name("solBroadcastRtx".to_string()) .spawn(move || loop { diff --git a/entry/src/entry.rs b/entry/src/entry.rs index 565eea085e..9a1ee0b73f 100644 --- a/entry/src/entry.rs +++ b/entry/src/entry.rs @@ -35,6 +35,7 @@ use { std::{ cmp, ffi::OsStr, + iter::repeat_with, sync::{Arc, Mutex, Once}, thread::{self, JoinHandle}, time::Instant, @@ -859,27 +860,19 @@ pub fn next_entry_mut(start: &mut Hash, num_hashes: u64, transactions: Vec Vec { - let mut ticks = Vec::with_capacity(num_ticks as usize); - for _ in 0..num_ticks { - let new_tick = next_entry_mut(&mut hash, hashes_per_tick, vec![]); - ticks.push(new_tick); - } - - ticks + repeat_with(|| next_entry_mut(&mut hash, hashes_per_tick, vec![])) + .take(num_ticks as usize) + .collect() } -#[allow(clippy::same_item_push)] pub fn create_random_ticks(num_ticks: u64, max_hashes_per_tick: u64, mut hash: Hash) -> Vec { - let mut ticks = Vec::with_capacity(num_ticks as usize); - for _ in 0..num_ticks { + repeat_with(|| { let hashes_per_tick = thread_rng().gen_range(1, max_hashes_per_tick); - let new_tick = next_entry_mut(&mut hash, hashes_per_tick, vec![]); - ticks.push(new_tick); - } - - ticks + next_entry_mut(&mut hash, hashes_per_tick, vec![]) + }) + .take(num_ticks as usize) + .collect() } /// Creates the next Tick or Transaction Entry `num_hashes` after `start_hash`. diff --git a/gossip/src/cluster_info.rs b/gossip/src/cluster_info.rs index 668c2325f4..cf5427cde5 100644 --- a/gossip/src/cluster_info.rs +++ b/gossip/src/cluster_info.rs @@ -4356,7 +4356,6 @@ RPC Enabled Nodes: 1"#; } #[test] - #[allow(clippy::same_item_push)] fn test_push_epoch_slots_large() { let node_keypair = Arc::new(Keypair::new()); let cluster_info = ClusterInfo::new( @@ -4364,12 +4363,15 @@ RPC Enabled Nodes: 1"#; node_keypair, SocketAddrSpace::Unspecified, ); - let mut range: Vec = vec![]; //random should be hard to compress - for _ in 0..32000 { - let last = *range.last().unwrap_or(&0); - range.push(last + rand::thread_rng().gen_range(1, 32)); - } + let mut rng = rand::thread_rng(); + let range: Vec = repeat_with(|| rng.gen_range(1, 32)) + .scan(0, |slot, step| { + *slot += step; + Some(*slot) + }) + .take(32000) + .collect(); cluster_info.push_epoch_slots(&range[..16000]); cluster_info.push_epoch_slots(&range[16000..]); let slots = cluster_info.get_epoch_slots(&mut Cursor::default()); diff --git a/gossip/src/epoch_slots.rs b/gossip/src/epoch_slots.rs index d3c842eb58..74d5edf81e 100644 --- a/gossip/src/epoch_slots.rs +++ b/gossip/src/epoch_slots.rs @@ -337,7 +337,8 @@ impl EpochSlots { #[cfg(test)] mod tests { - use super::*; + use {super::*, rand::Rng, std::iter::repeat_with}; + #[test] fn test_epoch_slots_max_size() { let epoch_slots = EpochSlots::default(); @@ -484,16 +485,18 @@ mod tests { assert_eq!(slots.to_slots(0), range); } + fn make_rand_slots(rng: &mut R) -> impl Iterator + '_ { + repeat_with(|| rng.gen_range(1, 5)).scan(0, |slot, step| { + *slot += step; + Some(*slot) + }) + } + #[test] - #[allow(clippy::same_item_push)] fn test_epoch_slots_fill_uncompressed_random_range() { - use rand::Rng; + let mut rng = rand::thread_rng(); for _ in 0..10 { - let mut range: Vec = vec![]; - for _ in 0..5000 { - let last = *range.last().unwrap_or(&0); - range.push(last + rand::thread_rng().gen_range(1, 5)); - } + let range: Vec = make_rand_slots(&mut rng).take(5000).collect(); let sz = EpochSlots::default().max_compressed_slot_size(); let mut slots = Uncompressed::new(sz as usize); let sz = slots.add(&range); @@ -504,15 +507,10 @@ mod tests { } #[test] - #[allow(clippy::same_item_push)] fn test_epoch_slots_fill_compressed_random_range() { - use rand::Rng; + let mut rng = rand::thread_rng(); for _ in 0..10 { - let mut range: Vec = vec![]; - for _ in 0..5000 { - let last = *range.last().unwrap_or(&0); - range.push(last + rand::thread_rng().gen_range(1, 5)); - } + let range: Vec = make_rand_slots(&mut rng).take(5000).collect(); let sz = EpochSlots::default().max_compressed_slot_size(); let mut slots = Uncompressed::new(sz as usize); let sz = slots.add(&range); @@ -525,15 +523,10 @@ mod tests { } #[test] - #[allow(clippy::same_item_push)] fn test_epoch_slots_fill_random_range() { - use rand::Rng; + let mut rng = rand::thread_rng(); for _ in 0..10 { - let mut range: Vec = vec![]; - for _ in 0..5000 { - let last = *range.last().unwrap_or(&0); - range.push(last + rand::thread_rng().gen_range(1, 5)); - } + let range: Vec = make_rand_slots(&mut rng).take(5000).collect(); let mut slots = EpochSlots::default(); let sz = slots.fill(&range, 1); let last = range[sz - 1]; diff --git a/ledger/src/blockstore.rs b/ledger/src/blockstore.rs index dc3f08b402..8e1552dc61 100644 --- a/ledger/src/blockstore.rs +++ b/ledger/src/blockstore.rs @@ -8421,18 +8421,17 @@ pub mod tests { } #[test] - #[allow(clippy::same_item_push)] fn test_get_last_hash() { - let mut entries: Vec = vec![]; + let entries: Vec = vec![]; let empty_entries_iterator = entries.iter(); assert!(get_last_hash(empty_entries_iterator).is_none()); - let mut prev_hash = hash::hash(&[42u8]); - for _ in 0..10 { - let entry = next_entry(&prev_hash, 1, vec![]); - prev_hash = entry.hash; - entries.push(entry); - } + let entry = next_entry(&hash::hash(&[42u8]), 1, vec![]); + let entries: Vec = std::iter::successors(Some(entry), |entry| { + Some(next_entry(&entry.hash, 1, vec![])) + }) + .take(10) + .collect(); let entries_iterator = entries.iter(); assert_eq!(get_last_hash(entries_iterator).unwrap(), entries[9].hash); } diff --git a/transaction-status/src/parse_stake.rs b/transaction-status/src/parse_stake.rs index d7da25b173..8993a3eb57 100644 --- a/transaction-status/src/parse_stake.rs +++ b/transaction-status/src/parse_stake.rs @@ -318,6 +318,7 @@ mod test { }, sysvar, }, + std::iter::repeat_with, }; #[test] @@ -760,12 +761,8 @@ mod test { } #[test] - #[allow(clippy::same_item_push)] fn test_parse_stake_set_lockup() { - let mut keys: Vec = vec![]; - for _ in 0..3 { - keys.push(Pubkey::new_unique()); - } + let keys: Vec = repeat_with(Pubkey::new_unique).take(3).collect(); let unix_timestamp = 1_234_567_890; let epoch = 11; let custodian = Pubkey::new_unique(); diff --git a/transaction-status/src/parse_token.rs b/transaction-status/src/parse_token.rs index 397aedc66b..d1b2ec6e7c 100644 --- a/transaction-status/src/parse_token.rs +++ b/transaction-status/src/parse_token.rs @@ -729,7 +729,7 @@ mod test { pubkey::Pubkey as SplTokenPubkey, }, }, - std::str::FromStr, + std::{iter::repeat_with, str::FromStr}, }; pub(super) fn convert_pubkey(pubkey: Pubkey) -> SplTokenPubkey { @@ -1711,13 +1711,11 @@ mod test { } #[test] - #[allow(clippy::same_item_push)] fn test_parse_token_v3() { test_parse_token(&spl_token::id()); } #[test] - #[allow(clippy::same_item_push)] fn test_parse_token_2022() { test_parse_token(&spl_token_2022::id()); } @@ -1747,10 +1745,7 @@ mod test { } fn test_token_ix_not_enough_keys(program_id: &SplTokenPubkey) { - let mut keys: Vec = vec![]; - for _ in 0..10 { - keys.push(solana_sdk::pubkey::new_rand()); - } + let keys: Vec = repeat_with(solana_sdk::pubkey::new_rand).take(10).collect(); // Test InitializeMint variations let initialize_mint_ix = initialize_mint( @@ -2225,13 +2220,11 @@ mod test { } #[test] - #[allow(clippy::same_item_push)] fn test_not_enough_keys_token_v3() { test_token_ix_not_enough_keys(&spl_token::id()); } #[test] - #[allow(clippy::same_item_push)] fn test_not_enough_keys_token_2022() { test_token_ix_not_enough_keys(&spl_token_2022::id()); }