blockworks-foundation
/
solana
mirror of https://github.com/blockworks-foundation/solana.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

removes #[allow(clippy::same_item_push)] (#29543)

This commit is contained in:
behzad nouri 2023-01-06 17:32:26 +00:00 committed by GitHub
parent 3fc4015a4d
commit 283a2b1540
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 83 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
core/benches/banking_stage.rs
View File

@ -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<Tra
.collect()
}
#[allow(clippy::same_item_push)]
fn make_programs_txs(txes: usize, hash: Hash) -> Vec<Transaction> {
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<Keypair> = vec![];
let keypairs: Vec<Keypair> = repeat_with(Keypair::new).take(num_accounts).collect();
let tx_vector: Vec<VersionedTransaction> = 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,

11
core/benches/retransmit_stage.rs
View File

@ -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);

53
core/src/broadcast_stage.rs
View File

@ -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<UdpSocket>,
cluster_info: Arc<ClusterInfo>,
@ -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 {

25
entry/src/entry.rs
View File

@ -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<Trans
entry
}
#[allow(clippy::same_item_push)]
pub fn create_ticks(num_ticks: u64, hashes_per_tick: u64, mut hash: Hash) -> Vec<Entry> {
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<Entry> {
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`.

14
gossip/src/cluster_info.rs
View File

@ -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<Slot> = 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<Slot> = 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());

37
gossip/src/epoch_slots.rs
View File

@ -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<R: Rng>(rng: &mut R) -> impl Iterator<Item = Slot> + '_ {
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<Slot> = 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<Slot> = 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<Slot> = 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<Slot> = 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<Slot> = 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<Slot> = make_rand_slots(&mut rng).take(5000).collect();
let mut slots = EpochSlots::default();
let sz = slots.fill(&range, 1);
let last = range[sz - 1];

15
ledger/src/blockstore.rs
View File

@ -8421,18 +8421,17 @@ pub mod tests {
}
#[test]
#[allow(clippy::same_item_push)]
fn test_get_last_hash() {
let mut entries: Vec<Entry> = vec![];
let entries: Vec<Entry> = 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<Entry> = 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);
}

7
transaction-status/src/parse_stake.rs
View File

@ -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<Pubkey> = vec![];
for _ in 0..3 {
keys.push(Pubkey::new_unique());
}
let keys: Vec<Pubkey> = repeat_with(Pubkey::new_unique).take(3).collect();
let unix_timestamp = 1_234_567_890;
let epoch = 11;
let custodian = Pubkey::new_unique();

11
transaction-status/src/parse_token.rs
View File

@ -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<Pubkey> = vec![];
for _ in 0..10 {
keys.push(solana_sdk::pubkey::new_rand());
}
let keys: Vec<Pubkey> = 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());
}