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

Avoid cloning Vec<Entry> when calling entries_to_test_shreds() (#22093)

This commit is contained in:
Yueh-Hsuan Chiang 2021-12-24 12:32:43 -08:00 committed by GitHub
parent 2ab4f34c02
commit b89cd8cd1a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 42 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
core/src/banking_stage.rs
View File

@ -2564,7 +2564,7 @@ mod tests {
poh_recorder.lock().unwrap().set_bank(&bank);
let shreds = entries_to_test_shreds(entries, bank.slot(), 0, true, 0);
let shreds = entries_to_test_shreds(&entries, bank.slot(), 0, true, 0);
blockstore.insert_shreds(shreds, None, false).unwrap();
blockstore.set_roots(std::iter::once(&bank.slot())).unwrap();

2
core/src/repair_generic_traversal.rs
View File

@ -302,7 +302,7 @@ pub mod test {
blockhashes.insert(slot, entries.last().unwrap().hash);
let mut shreds = solana_ledger::blockstore::entries_to_test_shreds(
entries.clone(),
&entries,
slot,
parent.unwrap_or(slot),
is_slot_complete,

14
core/src/replay_stage.rs
View File

@ -3389,7 +3389,7 @@ pub mod tests {
), // should cause AccountNotFound error
],
);
entries_to_test_shreds(vec![entry], slot, slot.saturating_sub(1), false, 0)
entries_to_test_shreds(&[entry], slot, slot.saturating_sub(1), false, 0)
});
assert_matches!(
@ -3419,7 +3419,7 @@ pub mod tests {
blockhash,
)],
);
entries_to_test_shreds(vec![entry], slot, slot.saturating_sub(1), false, 0)
entries_to_test_shreds(&[entry], slot, slot.saturating_sub(1), false, 0)
});
if let Err(BlockstoreProcessorError::InvalidBlock(block_error)) = res {
@ -3439,7 +3439,7 @@ pub mod tests {
let too_few_hashes_tick = Entry::new(&blockhash, hashes_per_tick - 1, vec![]);
entries_to_test_shreds(
vec![too_few_hashes_tick],
&[too_few_hashes_tick],
slot,
slot.saturating_sub(1),
false,
@ -3463,7 +3463,7 @@ pub mod tests {
let slot = bank.slot();
let hashes_per_tick = bank.hashes_per_tick().unwrap_or(0);
entries_to_test_shreds(
entry::create_ticks(bank.ticks_per_slot() + 1, hashes_per_tick, blockhash),
&entry::create_ticks(bank.ticks_per_slot() + 1, hashes_per_tick, blockhash),
slot,
slot.saturating_sub(1),
false,
@ -3483,7 +3483,7 @@ pub mod tests {
let slot = bank.slot();
let hashes_per_tick = bank.hashes_per_tick().unwrap_or(0);
entries_to_test_shreds(
entry::create_ticks(bank.ticks_per_slot() - 1, hashes_per_tick, blockhash),
&entry::create_ticks(bank.ticks_per_slot() - 1, hashes_per_tick, blockhash),
slot,
slot.saturating_sub(1),
true,
@ -3505,7 +3505,7 @@ pub mod tests {
let slot = bank.slot();
let hashes_per_tick = bank.hashes_per_tick().unwrap_or(0);
entries_to_test_shreds(
entry::create_ticks(bank.ticks_per_slot(), hashes_per_tick, blockhash),
&entry::create_ticks(bank.ticks_per_slot(), hashes_per_tick, blockhash),
slot,
slot.saturating_sub(1),
false,
@ -3533,7 +3533,7 @@ pub mod tests {
let tx = system_transaction::transfer(funded_keypair, &keypair.pubkey(), 2, blockhash);
let trailing_entry = entry::next_entry(&last_entry_hash, 1, vec![tx]);
entries.push(trailing_entry);
entries_to_test_shreds(entries, slot, slot.saturating_sub(1), true, 0)
entries_to_test_shreds(&entries, slot, slot.saturating_sub(1), true, 0)
});
if let Err(BlockstoreProcessorError::InvalidBlock(block_error)) = res {

2
core/src/validator.rs
View File

@ -1819,7 +1819,7 @@ mod tests {
info!("creating shreds");
let mut last_print = Instant::now();
for i in 1..10 {
let shreds = blockstore::entries_to_test_shreds(entries.clone(), i, i - 1, true, 1);
let shreds = blockstore::entries_to_test_shreds(&entries, i, i - 1, true, 1);
blockstore.insert_shreds(shreds, None, true).unwrap();
if last_print.elapsed().as_millis() > 5000 {
info!("inserted {}", i);

8
ledger/benches/blockstore.rs
View File

@ -20,7 +20,7 @@ fn bench_write_shreds(bench: &mut Bencher, entries: Vec<Entry>, ledger_path: &Pa
let blockstore =
Blockstore::open(ledger_path).expect("Expected to be able to open database ledger");
bench.iter(move || {
let shreds = entries_to_test_shreds(entries.clone(), 0, 0, true, 0);
let shreds = entries_to_test_shreds(&entries, 0, 0, true, 0);
blockstore.insert_shreds(shreds, None, false).unwrap();
});
@ -42,7 +42,7 @@ fn setup_read_bench(
);
// Convert the entries to shreds, write the shreds to the ledger
let shreds = entries_to_test_shreds(entries, slot, slot.saturating_sub(1), true, 0);
let shreds = entries_to_test_shreds(&entries, slot, slot.saturating_sub(1), true, 0);
blockstore
.insert_shreds(shreds, None, false)
.expect("Expectd successful insertion of shreds into ledger");
@ -135,7 +135,7 @@ fn bench_insert_data_shred_small(bench: &mut Bencher) {
let num_entries = 32 * 1024;
let entries = create_ticks(num_entries, 0, Hash::default());
bench.iter(move || {
let shreds = entries_to_test_shreds(entries.clone(), 0, 0, true, 0);
let shreds = entries_to_test_shreds(&entries, 0, 0, true, 0);
blockstore.insert_shreds(shreds, None, false).unwrap();
});
Blockstore::destroy(&ledger_path).expect("Expected successful database destruction");
@ -150,7 +150,7 @@ fn bench_insert_data_shred_big(bench: &mut Bencher) {
let num_entries = 32 * 1024;
let entries = create_ticks(num_entries, 0, Hash::default());
bench.iter(move || {
let shreds = entries_to_test_shreds(entries.clone(), 0, 0, true, 0);
let shreds = entries_to_test_shreds(&entries, 0, 0, true, 0);
blockstore.insert_shreds(shreds, None, false).unwrap();
});
Blockstore::destroy(&ledger_path).expect("Expected successful database destruction");

45
ledger/src/blockstore.rs
View File

@ -517,7 +517,7 @@ impl Blockstore {
entries.pop().unwrap();
}
let shreds = entries_to_test_shreds(
entries.clone(),
&entries,
slot,
parent.unwrap_or(slot),
is_slot_complete,
@ -3999,7 +3999,7 @@ pub fn create_new_ledger_from_name_auto_delete(
}
pub fn entries_to_test_shreds(
entries: Vec<Entry>,
entries: &[Entry],
slot: Slot,
parent_slot: Slot,
is_full_slot: bool,
@ -4009,7 +4009,7 @@ pub fn entries_to_test_shreds(
.unwrap()
.entries_to_shreds(
&Keypair::new(),
&entries,
entries,
is_full_slot,
0, // next_shred_index,
0, // next_code_index
@ -4024,7 +4024,7 @@ pub fn make_slot_entries(
num_entries: u64,
) -> (Vec<Shred>, Vec<Entry>) {
let entries = create_ticks(num_entries, 0, Hash::default());
let shreds = entries_to_test_shreds(entries.clone(), slot, parent_slot, true, 0);
let shreds = entries_to_test_shreds(&entries, slot, parent_slot, true, 0);
(shreds, entries)
}
@ -4567,12 +4567,12 @@ pub mod tests {
let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let entries = create_ticks(8, 0, Hash::default());
let shreds = entries_to_test_shreds(entries[0..4].to_vec(), 1, 0, false, 0);
let shreds = entries_to_test_shreds(&entries[0..4], 1, 0, false, 0);
blockstore
.insert_shreds(shreds, None, false)
.expect("Expected successful write of shreds");
let mut shreds1 = entries_to_test_shreds(entries[4..].to_vec(), 1, 0, false, 0);
let mut shreds1 = entries_to_test_shreds(&entries[4..], 1, 0, false, 0);
for (i, b) in shreds1.iter_mut().enumerate() {
b.set_index(8 + i as u32);
}
@ -4601,7 +4601,7 @@ pub mod tests {
let entries = create_ticks(slot + 1, 0, Hash::default());
let last_entry = entries.last().unwrap().clone();
let mut shreds =
entries_to_test_shreds(entries, slot, slot.saturating_sub(1), false, 0);
entries_to_test_shreds(&entries, slot, slot.saturating_sub(1), false, 0);
for b in shreds.iter_mut() {
b.set_index(index);
b.set_slot(slot as u64);
@ -4634,8 +4634,7 @@ pub mod tests {
// Write entries
for slot in 0..num_slots {
let entries = create_ticks(entries_per_slot, 0, Hash::default());
let shreds =
entries_to_test_shreds(entries.clone(), slot, slot.saturating_sub(1), false, 0);
let shreds = entries_to_test_shreds(&entries, slot, slot.saturating_sub(1), false, 0);
assert!(shreds.len() as u64 >= shreds_per_slot);
blockstore
.insert_shreds(shreds, None, false)
@ -4713,7 +4712,7 @@ pub mod tests {
let slot = 0;
let num_entries = max_ticks_per_n_shreds(1, None) + 1;
let entries = create_ticks(num_entries, slot, Hash::default());
let shreds = entries_to_test_shreds(entries, slot, 0, true, 0);
let shreds = entries_to_test_shreds(&entries, slot, 0, true, 0);
let num_shreds = shreds.len();
assert!(num_shreds > 1);
assert!(blockstore
@ -5432,7 +5431,7 @@ pub mod tests {
// Create enough entries to ensure there are at least two shreds created
let num_entries = max_ticks_per_n_shreds(1, None) + 1;
let entries = create_ticks(num_entries, 0, Hash::default());
let mut shreds = entries_to_test_shreds(entries, slot, 0, true, 0);
let mut shreds = entries_to_test_shreds(&entries, slot, 0, true, 0);
let num_shreds = shreds.len();
assert!(num_shreds > 1);
for (i, s) in shreds.iter_mut().enumerate() {
@ -5571,7 +5570,7 @@ pub mod tests {
);
let entries = create_ticks(100, 0, Hash::default());
let mut shreds = entries_to_test_shreds(entries, slot, 0, true, 0);
let mut shreds = entries_to_test_shreds(&entries, slot, 0, true, 0);
assert!(shreds.len() > 2);
shreds.drain(2..);
@ -5610,7 +5609,7 @@ pub mod tests {
// Write entries
let num_entries = 10;
let entries = create_ticks(num_entries, 0, Hash::default());
let shreds = entries_to_test_shreds(entries, slot, 0, true, 0);
let shreds = entries_to_test_shreds(&entries, slot, 0, true, 0);
let num_shreds = shreds.len();
blockstore.insert_shreds(shreds, None, false).unwrap();
@ -6138,7 +6137,7 @@ pub mod tests {
let num_ticks = 8;
let entries = create_ticks(num_ticks, 0, Hash::default());
let slot = 1;
let shreds = entries_to_test_shreds(entries, slot, 0, false, 0);
let shreds = entries_to_test_shreds(&entries, slot, 0, false, 0);
let next_shred_index = shreds.len();
blockstore
.insert_shreds(shreds, None, false)
@ -6226,9 +6225,9 @@ pub mod tests {
let slot = 10;
let entries = make_slot_entries_with_transactions(100);
let blockhash = get_last_hash(entries.iter()).unwrap();
let shreds = entries_to_test_shreds(entries.clone(), slot, slot - 1, true, 0);
let more_shreds = entries_to_test_shreds(entries.clone(), slot + 1, slot, true, 0);
let unrooted_shreds = entries_to_test_shreds(entries.clone(), slot + 2, slot + 1, true, 0);
let shreds = entries_to_test_shreds(&entries, slot, slot - 1, true, 0);
let more_shreds = entries_to_test_shreds(&entries, slot + 1, slot, true, 0);
let unrooted_shreds = entries_to_test_shreds(&entries, slot + 2, slot + 1, true, 0);
let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
blockstore.insert_shreds(shreds, None, false).unwrap();
@ -7095,7 +7094,7 @@ pub mod tests {
fn test_get_rooted_transaction() {
let slot = 2;
let entries = make_slot_entries_with_transactions(5);
let shreds = entries_to_test_shreds(entries.clone(), slot, slot - 1, true, 0);
let shreds = entries_to_test_shreds(&entries, slot, slot - 1, true, 0);
let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(ledger_path.path()).unwrap();
blockstore.insert_shreds(shreds, None, false).unwrap();
@ -7202,7 +7201,7 @@ pub mod tests {
let slot = 2;
let entries = make_slot_entries_with_transactions(5);
let shreds = entries_to_test_shreds(entries.clone(), slot, slot - 1, true, 0);
let shreds = entries_to_test_shreds(&entries, slot, slot - 1, true, 0);
blockstore.insert_shreds(shreds, None, false).unwrap();
let expected_transactions: Vec<TransactionWithStatusMeta> = entries
@ -7560,7 +7559,7 @@ pub mod tests {
let entries = make_slot_entries_with_transaction_addresses(&[
address0, address1, address0, address1,
]);
let shreds = entries_to_test_shreds(entries.clone(), slot, slot - 1, true, 0);
let shreds = entries_to_test_shreds(&entries, slot, slot - 1, true, 0);
blockstore.insert_shreds(shreds, None, false).unwrap();
for (i, entry) in entries.into_iter().enumerate() {
@ -7591,7 +7590,7 @@ pub mod tests {
let entries = make_slot_entries_with_transaction_addresses(&[
address0, address1, address0, address1,
]);
let shreds = entries_to_test_shreds(entries.clone(), slot, 8, true, 0);
let shreds = entries_to_test_shreds(&entries, slot, 8, true, 0);
blockstore.insert_shreds(shreds, None, false).unwrap();
for entry in entries.into_iter() {
@ -8611,7 +8610,7 @@ pub mod tests {
let parent = 0;
let num_txs = 20;
let entry = make_large_tx_entry(num_txs);
let shreds = entries_to_test_shreds(vec![entry], slot, parent, true, 0);
let shreds = entries_to_test_shreds(&[entry], slot, parent, true, 0);
assert!(shreds.len() > 1);
let ledger_path = get_tmp_ledger_path_auto_delete!();
@ -8697,7 +8696,7 @@ pub mod tests {
assert!(!blockstore.is_full(0));
}
let duplicate_shreds = entries_to_test_shreds(original_entries.clone(), 0, 0, true, 0);
let duplicate_shreds = entries_to_test_shreds(&original_entries, 0, 0, true, 0);
let num_shreds = duplicate_shreds.len() as u64;
blockstore
.insert_shreds(duplicate_shreds, None, false)

6
ledger/src/blockstore/blockstore_purge.rs
View File

@ -777,7 +777,7 @@ pub mod tests {
for x in 0..index0_max_slot + 1 {
let entries = make_slot_entries_with_transactions(1);
let shreds = entries_to_test_shreds(entries.clone(), x, x.saturating_sub(1), true, 0);
let shreds = entries_to_test_shreds(&entries, x, x.saturating_sub(1), true, 0);
blockstore.insert_shreds(shreds, None, false).unwrap();
let signature = entries
.iter()
@ -813,7 +813,7 @@ pub mod tests {
for x in index0_max_slot + 1..index1_max_slot + 1 {
let entries = make_slot_entries_with_transactions(1);
let shreds = entries_to_test_shreds(entries.clone(), x, x.saturating_sub(1), true, 0);
let shreds = entries_to_test_shreds(&entries, x, x.saturating_sub(1), true, 0);
blockstore.insert_shreds(shreds, None, false).unwrap();
let signature: Signature = entries
.iter()
@ -1213,7 +1213,7 @@ pub mod tests {
let mut tick = create_ticks(1, 0, hash(&serialize(&x).unwrap()));
entries.append(&mut tick);
}
let shreds = entries_to_test_shreds(entries, slot, slot - 1, true, 0);
let shreds = entries_to_test_shreds(&entries, slot, slot - 1, true, 0);
blockstore.insert_shreds(shreds, None, false).unwrap();
let mut write_batch = blockstore.db.batch().unwrap();

2
ledger/tests/blockstore.rs
View File

@ -21,7 +21,7 @@ fn test_multiple_threads_insert_shred() {
let threads: Vec<_> = (0..num_threads)
.map(|i| {
let entries = entry::create_ticks(1, 0, Hash::default());
let shreds = blockstore::entries_to_test_shreds(entries, i + 1, 0, false, 0);
let shreds = blockstore::entries_to_test_shreds(&entries, i + 1, 0, false, 0);
let blockstore_ = blockstore.clone();
Builder::new()
.name("blockstore-writer".to_string())

9
rpc/src/rpc.rs
View File

@ -4251,13 +4251,8 @@ pub fn create_test_transactions_and_populate_blockstore(
let entry_3 = solana_entry::entry::next_entry(&entry_2.hash, 1, vec![fail_tx]);
let entries = vec![entry_1, entry_2, entry_3];
let shreds = solana_ledger::blockstore::entries_to_test_shreds(
entries.clone(),
slot,
previous_slot,
true,
0,
);
let shreds =
solana_ledger::blockstore::entries_to_test_shreds(&entries, slot, previous_slot, true, 0);
blockstore.insert_shreds(shreds, None, false).unwrap();
blockstore.set_roots(std::iter::once(&slot)).unwrap();