blockworks-foundation
/
solana-with-rpc-optimizations
mirror of https://github.com/blockworks-foundation/solana-with-rpc-optimizations.git
1
0
Fork 0
Code Issues Packages 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); 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.insert_shreds(shreds, None, false).unwrap();
blockstore.set_roots(std::iter::once(&bank.slot())).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); blockhashes.insert(slot, entries.last().unwrap().hash);
let mut shreds = solana_ledger::blockstore::entries_to_test_shreds( let mut shreds = solana_ledger::blockstore::entries_to_test_shreds(
entries.clone(), &entries,
slot, slot,
parent.unwrap_or(slot), parent.unwrap_or(slot),
is_slot_complete, is_slot_complete,

14
core/src/replay_stage.rs
View File

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

2
core/src/validator.rs
View File

@ -1819,7 +1819,7 @@ mod tests {
info!("creating shreds"); info!("creating shreds");
let mut last_print = Instant::now(); let mut last_print = Instant::now();
for i in 1..10 { 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(); blockstore.insert_shreds(shreds, None, true).unwrap();
if last_print.elapsed().as_millis() > 5000 { if last_print.elapsed().as_millis() > 5000 {
info!("inserted {}", i); 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 = let blockstore =
Blockstore::open(ledger_path).expect("Expected to be able to open database ledger"); Blockstore::open(ledger_path).expect("Expected to be able to open database ledger");
bench.iter(move || { 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.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 // 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 blockstore
.insert_shreds(shreds, None, false) .insert_shreds(shreds, None, false)
.expect("Expectd successful insertion of shreds into ledger"); .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 num_entries = 32 * 1024;
let entries = create_ticks(num_entries, 0, Hash::default()); let entries = create_ticks(num_entries, 0, Hash::default());
bench.iter(move || { 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.insert_shreds(shreds, None, false).unwrap();
}); });
Blockstore::destroy(&ledger_path).expect("Expected successful database destruction"); 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 num_entries = 32 * 1024;
let entries = create_ticks(num_entries, 0, Hash::default()); let entries = create_ticks(num_entries, 0, Hash::default());
bench.iter(move || { 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.insert_shreds(shreds, None, false).unwrap();
}); });
Blockstore::destroy(&ledger_path).expect("Expected successful database destruction"); 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(); entries.pop().unwrap();
} }
let shreds = entries_to_test_shreds( let shreds = entries_to_test_shreds(
entries.clone(), &entries,
slot, slot,
parent.unwrap_or(slot), parent.unwrap_or(slot),
is_slot_complete, is_slot_complete,
@ -3999,7 +3999,7 @@ pub fn create_new_ledger_from_name_auto_delete(
} }
pub fn entries_to_test_shreds( pub fn entries_to_test_shreds(
entries: Vec<Entry>, entries: &[Entry],
slot: Slot, slot: Slot,
parent_slot: Slot, parent_slot: Slot,
is_full_slot: bool, is_full_slot: bool,
@ -4009,7 +4009,7 @@ pub fn entries_to_test_shreds(
.unwrap() .unwrap()
.entries_to_shreds( .entries_to_shreds(
&Keypair::new(), &Keypair::new(),
&entries, entries,
is_full_slot, is_full_slot,
0, // next_shred_index, 0, // next_shred_index,
0, // next_code_index 0, // next_code_index
@ -4024,7 +4024,7 @@ pub fn make_slot_entries(
num_entries: u64, num_entries: u64,
) -> (Vec<Shred>, Vec<Entry>) { ) -> (Vec<Shred>, Vec<Entry>) {
let entries = create_ticks(num_entries, 0, Hash::default()); 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) (shreds, entries)
} }
@ -4567,12 +4567,12 @@ pub mod tests {
let ledger_path = get_tmp_ledger_path_auto_delete!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(ledger_path.path()).unwrap(); let blockstore = Blockstore::open(ledger_path.path()).unwrap();
let entries = create_ticks(8, 0, Hash::default()); 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 blockstore
.insert_shreds(shreds, None, false) .insert_shreds(shreds, None, false)
.expect("Expected successful write of shreds"); .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() { for (i, b) in shreds1.iter_mut().enumerate() {
b.set_index(8 + i as u32); b.set_index(8 + i as u32);
} }
@ -4601,7 +4601,7 @@ pub mod tests {
let entries = create_ticks(slot + 1, 0, Hash::default()); let entries = create_ticks(slot + 1, 0, Hash::default());
let last_entry = entries.last().unwrap().clone(); let last_entry = entries.last().unwrap().clone();
let mut shreds = 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() { for b in shreds.iter_mut() {
b.set_index(index); b.set_index(index);
b.set_slot(slot as u64); b.set_slot(slot as u64);
@ -4634,8 +4634,7 @@ pub mod tests {
// Write entries // Write entries
for slot in 0..num_slots { for slot in 0..num_slots {
let entries = create_ticks(entries_per_slot, 0, Hash::default()); let entries = create_ticks(entries_per_slot, 0, Hash::default());
let shreds = let shreds = entries_to_test_shreds(&entries, slot, slot.saturating_sub(1), false, 0);
entries_to_test_shreds(entries.clone(), slot, slot.saturating_sub(1), false, 0);
assert!(shreds.len() as u64 >= shreds_per_slot); assert!(shreds.len() as u64 >= shreds_per_slot);
blockstore blockstore
.insert_shreds(shreds, None, false) .insert_shreds(shreds, None, false)
@ -4713,7 +4712,7 @@ pub mod tests {
let slot = 0; let slot = 0;
let num_entries = max_ticks_per_n_shreds(1, None) + 1; let num_entries = max_ticks_per_n_shreds(1, None) + 1;
let entries = create_ticks(num_entries, slot, Hash::default()); 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(); let num_shreds = shreds.len();
assert!(num_shreds > 1); assert!(num_shreds > 1);
assert!(blockstore assert!(blockstore
@ -5432,7 +5431,7 @@ pub mod tests {
// Create enough entries to ensure there are at least two shreds created // Create enough entries to ensure there are at least two shreds created
let num_entries = max_ticks_per_n_shreds(1, None) + 1; let num_entries = max_ticks_per_n_shreds(1, None) + 1;
let entries = create_ticks(num_entries, 0, Hash::default()); 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(); let num_shreds = shreds.len();
assert!(num_shreds > 1); assert!(num_shreds > 1);
for (i, s) in shreds.iter_mut().enumerate() { for (i, s) in shreds.iter_mut().enumerate() {
@ -5571,7 +5570,7 @@ pub mod tests {
); );
let entries = create_ticks(100, 0, Hash::default()); 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); assert!(shreds.len() > 2);
shreds.drain(2..); shreds.drain(2..);
@ -5610,7 +5609,7 @@ pub mod tests {
// Write entries // Write entries
let num_entries = 10; let num_entries = 10;
let entries = create_ticks(num_entries, 0, Hash::default()); 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(); let num_shreds = shreds.len();
blockstore.insert_shreds(shreds, None, false).unwrap(); blockstore.insert_shreds(shreds, None, false).unwrap();
@ -6138,7 +6137,7 @@ pub mod tests {
let num_ticks = 8; let num_ticks = 8;
let entries = create_ticks(num_ticks, 0, Hash::default()); let entries = create_ticks(num_ticks, 0, Hash::default());
let slot = 1; 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(); let next_shred_index = shreds.len();
blockstore blockstore
.insert_shreds(shreds, None, false) .insert_shreds(shreds, None, false)
@ -6226,9 +6225,9 @@ pub mod tests {
let slot = 10; let slot = 10;
let entries = make_slot_entries_with_transactions(100); let entries = make_slot_entries_with_transactions(100);
let blockhash = get_last_hash(entries.iter()).unwrap(); let blockhash = get_last_hash(entries.iter()).unwrap();
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 more_shreds = entries_to_test_shreds(entries.clone(), slot + 1, slot, true, 0); let more_shreds = entries_to_test_shreds(&entries, slot + 1, slot, true, 0);
let unrooted_shreds = entries_to_test_shreds(entries.clone(), slot + 2, slot + 1, 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 ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(ledger_path.path()).unwrap(); let blockstore = Blockstore::open(ledger_path.path()).unwrap();
blockstore.insert_shreds(shreds, None, false).unwrap(); blockstore.insert_shreds(shreds, None, false).unwrap();
@ -7095,7 +7094,7 @@ pub mod tests {
fn test_get_rooted_transaction() { fn test_get_rooted_transaction() {
let slot = 2; let slot = 2;
let entries = make_slot_entries_with_transactions(5); 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 ledger_path = get_tmp_ledger_path_auto_delete!();
let blockstore = Blockstore::open(ledger_path.path()).unwrap(); let blockstore = Blockstore::open(ledger_path.path()).unwrap();
blockstore.insert_shreds(shreds, None, false).unwrap(); blockstore.insert_shreds(shreds, None, false).unwrap();
@ -7202,7 +7201,7 @@ pub mod tests {
let slot = 2; let slot = 2;
let entries = make_slot_entries_with_transactions(5); 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(); blockstore.insert_shreds(shreds, None, false).unwrap();
let expected_transactions: Vec<TransactionWithStatusMeta> = entries let expected_transactions: Vec<TransactionWithStatusMeta> = entries
@ -7560,7 +7559,7 @@ pub mod tests {
let entries = make_slot_entries_with_transaction_addresses(&[ let entries = make_slot_entries_with_transaction_addresses(&[
address0, address1, address0, address1, 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(); blockstore.insert_shreds(shreds, None, false).unwrap();
for (i, entry) in entries.into_iter().enumerate() { for (i, entry) in entries.into_iter().enumerate() {
@ -7591,7 +7590,7 @@ pub mod tests {
let entries = make_slot_entries_with_transaction_addresses(&[ let entries = make_slot_entries_with_transaction_addresses(&[
address0, address1, address0, address1, 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(); blockstore.insert_shreds(shreds, None, false).unwrap();
for entry in entries.into_iter() { for entry in entries.into_iter() {
@ -8611,7 +8610,7 @@ pub mod tests {
let parent = 0; let parent = 0;
let num_txs = 20; let num_txs = 20;
let entry = make_large_tx_entry(num_txs); 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); assert!(shreds.len() > 1);
let ledger_path = get_tmp_ledger_path_auto_delete!(); let ledger_path = get_tmp_ledger_path_auto_delete!();
@ -8697,7 +8696,7 @@ pub mod tests {
assert!(!blockstore.is_full(0)); 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; let num_shreds = duplicate_shreds.len() as u64;
blockstore blockstore
.insert_shreds(duplicate_shreds, None, false) .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 { for x in 0..index0_max_slot + 1 {
let entries = make_slot_entries_with_transactions(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(); blockstore.insert_shreds(shreds, None, false).unwrap();
let signature = entries let signature = entries
.iter() .iter()
@ -813,7 +813,7 @@ pub mod tests {
for x in index0_max_slot + 1..index1_max_slot + 1 { for x in index0_max_slot + 1..index1_max_slot + 1 {
let entries = make_slot_entries_with_transactions(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(); blockstore.insert_shreds(shreds, None, false).unwrap();
let signature: Signature = entries let signature: Signature = entries
.iter() .iter()
@ -1213,7 +1213,7 @@ pub mod tests {
let mut tick = create_ticks(1, 0, hash(&serialize(&x).unwrap())); let mut tick = create_ticks(1, 0, hash(&serialize(&x).unwrap()));
entries.append(&mut tick); 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(); blockstore.insert_shreds(shreds, None, false).unwrap();
let mut write_batch = blockstore.db.batch().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) let threads: Vec<_> = (0..num_threads)
.map(|i| { .map(|i| {
let entries = entry::create_ticks(1, 0, Hash::default()); 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(); let blockstore_ = blockstore.clone();
Builder::new() Builder::new()
.name("blockstore-writer".to_string()) .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 entry_3 = solana_entry::entry::next_entry(&entry_2.hash, 1, vec![fail_tx]);
let entries = vec![entry_1, entry_2, entry_3]; let entries = vec![entry_1, entry_2, entry_3];
let shreds = solana_ledger::blockstore::entries_to_test_shreds( let shreds =
entries.clone(), solana_ledger::blockstore::entries_to_test_shreds(&entries, slot, previous_slot, true, 0);
slot,
previous_slot,
true,
0,
);
blockstore.insert_shreds(shreds, None, false).unwrap(); blockstore.insert_shreds(shreds, None, false).unwrap();
blockstore.set_roots(std::iter::once(&slot)).unwrap(); blockstore.set_roots(std::iter::once(&slot)).unwrap();