2019-10-07 11:08:01 -07:00
|
|
|
//! The `shred_fetch_stage` pulls shreds from UDP sockets and sends it to a channel.
|
2018-06-13 21:52:23 -07:00
|
|
|
|
2021-12-03 09:00:31 -08:00
|
|
|
use {
|
|
|
|
crate::packet_hasher::PacketHasher,
|
|
|
|
lru::LruCache,
|
|
|
|
solana_ledger::shred::{get_shred_slot_index_type, ShredFetchStats},
|
|
|
|
solana_perf::{
|
|
|
|
cuda_runtime::PinnedVec,
|
2022-01-02 09:10:32 -08:00
|
|
|
packet::{Packet, PacketBatchRecycler, PacketFlags},
|
2021-12-03 09:00:31 -08:00
|
|
|
recycler::Recycler,
|
|
|
|
},
|
|
|
|
solana_runtime::bank_forks::BankForks,
|
|
|
|
solana_sdk::clock::{Slot, DEFAULT_MS_PER_SLOT},
|
2021-12-11 06:44:15 -08:00
|
|
|
solana_streamer::streamer::{self, PacketBatchReceiver, PacketBatchSender},
|
2021-12-03 09:00:31 -08:00
|
|
|
std::{
|
|
|
|
net::UdpSocket,
|
|
|
|
sync::{atomic::AtomicBool, mpsc::channel, Arc, RwLock},
|
|
|
|
thread::{self, Builder, JoinHandle},
|
|
|
|
time::Instant,
|
|
|
|
},
|
|
|
|
};
|
2020-03-20 07:49:48 -07:00
|
|
|
|
2020-12-07 16:42:39 -08:00
|
|
|
const DEFAULT_LRU_SIZE: usize = 10_000;
|
|
|
|
pub type ShredsReceived = LruCache<u64, ()>;
|
2018-06-13 21:52:23 -07:00
|
|
|
|
2019-10-07 11:08:01 -07:00
|
|
|
pub struct ShredFetchStage {
|
2018-07-03 21:14:08 -07:00
|
|
|
thread_hdls: Vec<JoinHandle<()>>,
|
2018-06-13 21:52:23 -07:00
|
|
|
}
|
|
|
|
|
2019-10-07 11:08:01 -07:00
|
|
|
impl ShredFetchStage {
|
2020-03-20 07:49:48 -07:00
|
|
|
fn process_packet<F>(
|
|
|
|
p: &mut Packet,
|
|
|
|
shreds_received: &mut ShredsReceived,
|
2020-05-10 21:37:05 -07:00
|
|
|
stats: &mut ShredFetchStats,
|
2020-03-20 07:49:48 -07:00
|
|
|
last_root: Slot,
|
|
|
|
last_slot: Slot,
|
|
|
|
slots_per_epoch: u64,
|
|
|
|
modify: &F,
|
2020-12-15 16:50:40 -08:00
|
|
|
packet_hasher: &PacketHasher,
|
2020-03-20 07:49:48 -07:00
|
|
|
) where
|
|
|
|
F: Fn(&mut Packet),
|
|
|
|
{
|
2022-01-02 09:10:32 -08:00
|
|
|
p.meta.set_discard(true);
|
2020-12-15 16:50:40 -08:00
|
|
|
if let Some((slot, _index, _shred_type)) = get_shred_slot_index_type(p, stats) {
|
2020-03-20 11:00:48 -07:00
|
|
|
// Seems reasonable to limit shreds to 2 epochs away
|
2020-12-15 16:50:40 -08:00
|
|
|
if slot > last_root && slot < (last_slot + 2 * slots_per_epoch) {
|
|
|
|
// Shred filter
|
|
|
|
|
|
|
|
let hash = packet_hasher.hash_packet(p);
|
|
|
|
|
|
|
|
if shreds_received.get(&hash).is_none() {
|
|
|
|
shreds_received.put(hash, ());
|
2022-01-02 09:10:32 -08:00
|
|
|
p.meta.set_discard(false);
|
2020-12-15 16:50:40 -08:00
|
|
|
modify(p);
|
|
|
|
} else {
|
|
|
|
stats.duplicate_shred += 1;
|
2020-03-20 07:49:48 -07:00
|
|
|
}
|
2020-05-10 21:37:05 -07:00
|
|
|
} else {
|
|
|
|
stats.slot_out_of_range += 1;
|
2020-03-20 07:49:48 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-10-09 13:11:19 -07:00
|
|
|
// updates packets received on a channel and sends them on another channel
|
2020-03-20 07:49:48 -07:00
|
|
|
fn modify_packets<F>(
|
2021-12-11 06:44:15 -08:00
|
|
|
recvr: PacketBatchReceiver,
|
|
|
|
sendr: PacketBatchSender,
|
2020-03-20 07:49:48 -07:00
|
|
|
bank_forks: Option<Arc<RwLock<BankForks>>>,
|
2020-05-10 21:37:05 -07:00
|
|
|
name: &'static str,
|
2020-03-20 07:49:48 -07:00
|
|
|
modify: F,
|
|
|
|
) where
|
2019-10-09 13:11:19 -07:00
|
|
|
F: Fn(&mut Packet),
|
|
|
|
{
|
2020-12-07 16:42:39 -08:00
|
|
|
let mut shreds_received = LruCache::new(DEFAULT_LRU_SIZE);
|
|
|
|
let mut last_updated = Instant::now();
|
2020-03-20 07:49:48 -07:00
|
|
|
|
|
|
|
// In the case of bank_forks=None, setup to accept any slot range
|
|
|
|
let mut last_root = 0;
|
|
|
|
let mut last_slot = std::u64::MAX;
|
|
|
|
let mut slots_per_epoch = 0;
|
|
|
|
|
2020-05-10 21:37:05 -07:00
|
|
|
let mut last_stats = Instant::now();
|
|
|
|
let mut stats = ShredFetchStats::default();
|
2020-12-15 16:50:40 -08:00
|
|
|
let mut packet_hasher = PacketHasher::default();
|
2020-05-10 21:37:05 -07:00
|
|
|
|
2021-12-11 06:44:15 -08:00
|
|
|
while let Some(mut packet_batch) = recvr.iter().next() {
|
2020-12-07 16:42:39 -08:00
|
|
|
if last_updated.elapsed().as_millis() as u64 > DEFAULT_MS_PER_SLOT {
|
|
|
|
last_updated = Instant::now();
|
2020-12-15 16:50:40 -08:00
|
|
|
packet_hasher.reset();
|
2020-03-20 07:49:48 -07:00
|
|
|
shreds_received.clear();
|
|
|
|
if let Some(bank_forks) = bank_forks.as_ref() {
|
|
|
|
let bank_forks_r = bank_forks.read().unwrap();
|
|
|
|
last_root = bank_forks_r.root();
|
|
|
|
let working_bank = bank_forks_r.working_bank();
|
|
|
|
last_slot = working_bank.slot();
|
|
|
|
let root_bank = bank_forks_r.root_bank();
|
|
|
|
slots_per_epoch = root_bank.get_slots_in_epoch(root_bank.epoch());
|
2019-12-30 07:42:09 -08:00
|
|
|
}
|
2020-03-20 07:49:48 -07:00
|
|
|
}
|
2021-12-11 06:44:15 -08:00
|
|
|
stats.shred_count += packet_batch.packets.len();
|
|
|
|
packet_batch.packets.iter_mut().for_each(|packet| {
|
2020-03-20 07:49:48 -07:00
|
|
|
Self::process_packet(
|
2021-10-05 22:24:48 -07:00
|
|
|
packet,
|
2020-03-20 07:49:48 -07:00
|
|
|
&mut shreds_received,
|
2020-05-10 21:37:05 -07:00
|
|
|
&mut stats,
|
2020-03-20 07:49:48 -07:00
|
|
|
last_root,
|
|
|
|
last_slot,
|
|
|
|
slots_per_epoch,
|
|
|
|
&modify,
|
2020-12-15 16:50:40 -08:00
|
|
|
&packet_hasher,
|
2020-03-20 07:49:48 -07:00
|
|
|
);
|
2019-12-30 07:42:09 -08:00
|
|
|
});
|
2020-05-10 21:37:05 -07:00
|
|
|
if last_stats.elapsed().as_millis() > 1000 {
|
|
|
|
datapoint_info!(
|
|
|
|
name,
|
|
|
|
("index_overrun", stats.index_overrun, i64),
|
|
|
|
("shred_count", stats.shred_count, i64),
|
|
|
|
("slot_bad_deserialize", stats.slot_bad_deserialize, i64),
|
|
|
|
("index_bad_deserialize", stats.index_bad_deserialize, i64),
|
|
|
|
("index_out_of_bounds", stats.index_out_of_bounds, i64),
|
|
|
|
("slot_out_of_range", stats.slot_out_of_range, i64),
|
|
|
|
("duplicate_shred", stats.duplicate_shred, i64),
|
|
|
|
);
|
|
|
|
stats = ShredFetchStats::default();
|
|
|
|
last_stats = Instant::now();
|
|
|
|
}
|
2021-12-11 06:44:15 -08:00
|
|
|
if sendr.send(packet_batch).is_err() {
|
2019-10-09 13:11:19 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
fn packet_modifier<F>(
|
|
|
|
sockets: Vec<Arc<UdpSocket>>,
|
|
|
|
exit: &Arc<AtomicBool>,
|
2021-12-11 06:44:15 -08:00
|
|
|
sender: PacketBatchSender,
|
2019-10-09 13:11:19 -07:00
|
|
|
recycler: Recycler<PinnedVec<Packet>>,
|
2020-03-20 07:49:48 -07:00
|
|
|
bank_forks: Option<Arc<RwLock<BankForks>>>,
|
2020-05-10 21:37:05 -07:00
|
|
|
name: &'static str,
|
2019-10-09 13:11:19 -07:00
|
|
|
modify: F,
|
|
|
|
) -> (Vec<JoinHandle<()>>, JoinHandle<()>)
|
|
|
|
where
|
|
|
|
F: Fn(&mut Packet) + Send + 'static,
|
|
|
|
{
|
|
|
|
let (packet_sender, packet_receiver) = channel();
|
|
|
|
let streamers = sockets
|
|
|
|
.into_iter()
|
|
|
|
.map(|s| {
|
|
|
|
streamer::receiver(
|
|
|
|
s,
|
2021-06-18 06:34:46 -07:00
|
|
|
exit,
|
2019-10-09 13:11:19 -07:00
|
|
|
packet_sender.clone(),
|
|
|
|
recycler.clone(),
|
|
|
|
"packet_modifier",
|
2021-02-26 09:15:45 -08:00
|
|
|
1,
|
2021-06-14 07:10:04 -07:00
|
|
|
true,
|
2019-10-09 13:11:19 -07:00
|
|
|
)
|
|
|
|
})
|
|
|
|
.collect();
|
2019-12-19 23:27:54 -08:00
|
|
|
|
2019-10-09 13:11:19 -07:00
|
|
|
let modifier_hdl = Builder::new()
|
|
|
|
.name("solana-tvu-fetch-stage-packet-modifier".to_string())
|
2020-05-10 21:37:05 -07:00
|
|
|
.spawn(move || Self::modify_packets(packet_receiver, sender, bank_forks, name, modify))
|
2019-10-09 13:11:19 -07:00
|
|
|
.unwrap();
|
|
|
|
(streamers, modifier_hdl)
|
|
|
|
}
|
|
|
|
|
2019-10-09 10:36:05 -07:00
|
|
|
pub fn new(
|
2019-08-20 17:16:06 -07:00
|
|
|
sockets: Vec<Arc<UdpSocket>>,
|
|
|
|
forward_sockets: Vec<Arc<UdpSocket>>,
|
2019-10-09 13:11:19 -07:00
|
|
|
repair_socket: Arc<UdpSocket>,
|
2021-12-11 06:44:15 -08:00
|
|
|
sender: &PacketBatchSender,
|
2020-03-20 07:49:48 -07:00
|
|
|
bank_forks: Option<Arc<RwLock<BankForks>>>,
|
2019-08-20 17:16:06 -07:00
|
|
|
exit: &Arc<AtomicBool>,
|
|
|
|
) -> Self {
|
2021-12-11 06:44:15 -08:00
|
|
|
let recycler: PacketBatchRecycler = Recycler::warmed(100, 1024);
|
2019-11-07 19:48:33 -08:00
|
|
|
|
2020-12-07 16:42:39 -08:00
|
|
|
let (mut tvu_threads, tvu_filter) = Self::packet_modifier(
|
|
|
|
sockets,
|
2021-06-18 06:34:46 -07:00
|
|
|
exit,
|
2020-12-07 16:42:39 -08:00
|
|
|
sender.clone(),
|
|
|
|
recycler.clone(),
|
|
|
|
bank_forks.clone(),
|
|
|
|
"shred_fetch",
|
|
|
|
|_| {},
|
|
|
|
);
|
2019-08-20 17:16:06 -07:00
|
|
|
|
2019-10-09 13:11:19 -07:00
|
|
|
let (tvu_forwards_threads, fwd_thread_hdl) = Self::packet_modifier(
|
|
|
|
forward_sockets,
|
2021-06-18 06:34:46 -07:00
|
|
|
exit,
|
2019-10-09 13:11:19 -07:00
|
|
|
sender.clone(),
|
|
|
|
recycler.clone(),
|
2020-03-20 07:49:48 -07:00
|
|
|
bank_forks.clone(),
|
2020-05-10 21:37:05 -07:00
|
|
|
"shred_fetch_tvu_forwards",
|
2022-01-02 09:10:32 -08:00
|
|
|
|p| p.meta.flags.insert(PacketFlags::FORWARDED),
|
2019-10-09 13:11:19 -07:00
|
|
|
);
|
2019-08-20 17:16:06 -07:00
|
|
|
|
2019-10-09 13:11:19 -07:00
|
|
|
let (repair_receiver, repair_handler) = Self::packet_modifier(
|
|
|
|
vec![repair_socket],
|
2021-06-18 06:34:46 -07:00
|
|
|
exit,
|
2019-10-09 13:11:19 -07:00
|
|
|
sender.clone(),
|
2020-12-07 16:42:39 -08:00
|
|
|
recycler,
|
2020-03-20 07:49:48 -07:00
|
|
|
bank_forks,
|
2020-05-10 21:37:05 -07:00
|
|
|
"shred_fetch_repair",
|
2022-01-02 09:10:32 -08:00
|
|
|
|p| p.meta.flags.insert(PacketFlags::REPAIR),
|
2019-10-09 13:11:19 -07:00
|
|
|
);
|
2019-08-20 17:16:06 -07:00
|
|
|
|
2020-12-07 16:42:39 -08:00
|
|
|
tvu_threads.extend(tvu_forwards_threads.into_iter());
|
|
|
|
tvu_threads.extend(repair_receiver.into_iter());
|
|
|
|
tvu_threads.push(tvu_filter);
|
|
|
|
tvu_threads.push(fwd_thread_hdl);
|
|
|
|
tvu_threads.push(repair_handler);
|
2019-08-20 17:16:06 -07:00
|
|
|
|
2020-12-07 16:42:39 -08:00
|
|
|
Self {
|
|
|
|
thread_hdls: tvu_threads,
|
|
|
|
}
|
2019-08-20 17:16:06 -07:00
|
|
|
}
|
2018-07-03 21:14:08 -07:00
|
|
|
|
2019-11-13 10:12:09 -08:00
|
|
|
pub fn join(self) -> thread::Result<()> {
|
2018-09-13 14:00:17 -07:00
|
|
|
for thread_hdl in self.thread_hdls {
|
2018-07-03 21:14:08 -07:00
|
|
|
thread_hdl.join()?;
|
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
}
|
2020-03-20 07:49:48 -07:00
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2021-12-03 09:00:31 -08:00
|
|
|
use {
|
|
|
|
super::*,
|
|
|
|
solana_ledger::{blockstore::MAX_DATA_SHREDS_PER_SLOT, shred::Shred},
|
|
|
|
};
|
2020-03-20 07:49:48 -07:00
|
|
|
|
2020-05-15 13:23:56 -07:00
|
|
|
#[test]
|
|
|
|
fn test_data_code_same_index() {
|
|
|
|
solana_logger::setup();
|
2020-12-07 16:42:39 -08:00
|
|
|
let mut shreds_received = LruCache::new(DEFAULT_LRU_SIZE);
|
2020-05-15 13:23:56 -07:00
|
|
|
let mut packet = Packet::default();
|
|
|
|
let mut stats = ShredFetchStats::default();
|
|
|
|
|
|
|
|
let slot = 1;
|
2021-03-23 07:52:38 -07:00
|
|
|
let shred = Shred::new_from_data(
|
|
|
|
slot, 3, // shred index
|
|
|
|
0, // parent offset
|
|
|
|
None, // data
|
|
|
|
true, // is_last_in_fec_set
|
|
|
|
true, // is_last_in_slot
|
|
|
|
0, // reference_tick
|
|
|
|
0, // version
|
|
|
|
3, // fec_set_index
|
|
|
|
);
|
2020-05-15 13:23:56 -07:00
|
|
|
shred.copy_to_packet(&mut packet);
|
|
|
|
|
2020-12-15 16:50:40 -08:00
|
|
|
let hasher = PacketHasher::default();
|
2020-12-07 16:42:39 -08:00
|
|
|
|
2020-05-15 13:23:56 -07:00
|
|
|
let last_root = 0;
|
|
|
|
let last_slot = 100;
|
|
|
|
let slots_per_epoch = 10;
|
|
|
|
ShredFetchStage::process_packet(
|
|
|
|
&mut packet,
|
|
|
|
&mut shreds_received,
|
|
|
|
&mut stats,
|
|
|
|
last_root,
|
|
|
|
last_slot,
|
|
|
|
slots_per_epoch,
|
|
|
|
&|_p| {},
|
2020-12-15 16:50:40 -08:00
|
|
|
&hasher,
|
2020-05-15 13:23:56 -07:00
|
|
|
);
|
2022-01-02 09:10:32 -08:00
|
|
|
assert!(!packet.meta.discard());
|
2021-04-21 05:47:50 -07:00
|
|
|
let coding = solana_ledger::shred::Shredder::generate_coding_shreds(
|
|
|
|
&[shred],
|
|
|
|
false, // is_last_in_slot
|
2021-12-19 14:37:55 -08:00
|
|
|
3, // next_code_index
|
2021-04-21 05:47:50 -07:00
|
|
|
);
|
2020-05-15 13:23:56 -07:00
|
|
|
coding[0].copy_to_packet(&mut packet);
|
|
|
|
ShredFetchStage::process_packet(
|
|
|
|
&mut packet,
|
|
|
|
&mut shreds_received,
|
|
|
|
&mut stats,
|
|
|
|
last_root,
|
|
|
|
last_slot,
|
|
|
|
slots_per_epoch,
|
|
|
|
&|_p| {},
|
2020-12-15 16:50:40 -08:00
|
|
|
&hasher,
|
2020-05-15 13:23:56 -07:00
|
|
|
);
|
2022-01-02 09:10:32 -08:00
|
|
|
assert!(!packet.meta.discard());
|
2020-05-15 13:23:56 -07:00
|
|
|
}
|
|
|
|
|
2020-03-20 07:49:48 -07:00
|
|
|
#[test]
|
|
|
|
fn test_shred_filter() {
|
|
|
|
solana_logger::setup();
|
2020-12-07 16:42:39 -08:00
|
|
|
let mut shreds_received = LruCache::new(DEFAULT_LRU_SIZE);
|
2020-03-20 07:49:48 -07:00
|
|
|
let mut packet = Packet::default();
|
2020-05-10 21:37:05 -07:00
|
|
|
let mut stats = ShredFetchStats::default();
|
2020-03-20 07:49:48 -07:00
|
|
|
let last_root = 0;
|
|
|
|
let last_slot = 100;
|
|
|
|
let slots_per_epoch = 10;
|
2020-12-15 16:50:40 -08:00
|
|
|
|
|
|
|
let hasher = PacketHasher::default();
|
|
|
|
|
2020-03-20 07:49:48 -07:00
|
|
|
// packet size is 0, so cannot get index
|
|
|
|
ShredFetchStage::process_packet(
|
|
|
|
&mut packet,
|
|
|
|
&mut shreds_received,
|
2020-05-10 21:37:05 -07:00
|
|
|
&mut stats,
|
2020-03-20 07:49:48 -07:00
|
|
|
last_root,
|
|
|
|
last_slot,
|
|
|
|
slots_per_epoch,
|
|
|
|
&|_p| {},
|
2020-12-15 16:50:40 -08:00
|
|
|
&hasher,
|
2020-03-20 07:49:48 -07:00
|
|
|
);
|
2020-05-10 21:37:05 -07:00
|
|
|
assert_eq!(stats.index_overrun, 1);
|
2022-01-02 09:10:32 -08:00
|
|
|
assert!(packet.meta.discard());
|
2020-03-20 07:49:48 -07:00
|
|
|
let shred = Shred::new_from_data(1, 3, 0, None, true, true, 0, 0, 0);
|
|
|
|
shred.copy_to_packet(&mut packet);
|
|
|
|
|
|
|
|
// rejected slot is 1, root is 3
|
|
|
|
ShredFetchStage::process_packet(
|
|
|
|
&mut packet,
|
|
|
|
&mut shreds_received,
|
2020-05-10 21:37:05 -07:00
|
|
|
&mut stats,
|
2020-03-20 07:49:48 -07:00
|
|
|
3,
|
|
|
|
last_slot,
|
|
|
|
slots_per_epoch,
|
|
|
|
&|_p| {},
|
2020-12-15 16:50:40 -08:00
|
|
|
&hasher,
|
2020-03-20 07:49:48 -07:00
|
|
|
);
|
2022-01-02 09:10:32 -08:00
|
|
|
assert!(packet.meta.discard());
|
2020-03-20 07:49:48 -07:00
|
|
|
|
|
|
|
// Accepted for 1,3
|
|
|
|
ShredFetchStage::process_packet(
|
|
|
|
&mut packet,
|
|
|
|
&mut shreds_received,
|
2020-05-10 21:37:05 -07:00
|
|
|
&mut stats,
|
2020-03-20 07:49:48 -07:00
|
|
|
last_root,
|
|
|
|
last_slot,
|
|
|
|
slots_per_epoch,
|
|
|
|
&|_p| {},
|
2020-12-15 16:50:40 -08:00
|
|
|
&hasher,
|
2020-03-20 07:49:48 -07:00
|
|
|
);
|
2022-01-02 09:10:32 -08:00
|
|
|
assert!(!packet.meta.discard());
|
2020-03-20 07:49:48 -07:00
|
|
|
|
|
|
|
// shreds_received should filter duplicate
|
|
|
|
ShredFetchStage::process_packet(
|
|
|
|
&mut packet,
|
|
|
|
&mut shreds_received,
|
2020-05-10 21:37:05 -07:00
|
|
|
&mut stats,
|
2020-03-20 07:49:48 -07:00
|
|
|
last_root,
|
|
|
|
last_slot,
|
|
|
|
slots_per_epoch,
|
|
|
|
&|_p| {},
|
2020-12-15 16:50:40 -08:00
|
|
|
&hasher,
|
2020-03-20 07:49:48 -07:00
|
|
|
);
|
2022-01-02 09:10:32 -08:00
|
|
|
assert!(packet.meta.discard());
|
2020-03-20 07:49:48 -07:00
|
|
|
|
|
|
|
let shred = Shred::new_from_data(1_000_000, 3, 0, None, true, true, 0, 0, 0);
|
|
|
|
shred.copy_to_packet(&mut packet);
|
|
|
|
|
|
|
|
// Slot 1 million is too high
|
|
|
|
ShredFetchStage::process_packet(
|
|
|
|
&mut packet,
|
|
|
|
&mut shreds_received,
|
2020-05-10 21:37:05 -07:00
|
|
|
&mut stats,
|
2020-03-20 07:49:48 -07:00
|
|
|
last_root,
|
|
|
|
last_slot,
|
|
|
|
slots_per_epoch,
|
|
|
|
&|_p| {},
|
2020-12-15 16:50:40 -08:00
|
|
|
&hasher,
|
2020-03-20 07:49:48 -07:00
|
|
|
);
|
2022-01-02 09:10:32 -08:00
|
|
|
assert!(packet.meta.discard());
|
2020-03-20 07:49:48 -07:00
|
|
|
|
|
|
|
let index = MAX_DATA_SHREDS_PER_SLOT as u32;
|
|
|
|
let shred = Shred::new_from_data(5, index, 0, None, true, true, 0, 0, 0);
|
|
|
|
shred.copy_to_packet(&mut packet);
|
|
|
|
ShredFetchStage::process_packet(
|
|
|
|
&mut packet,
|
|
|
|
&mut shreds_received,
|
2020-05-10 21:37:05 -07:00
|
|
|
&mut stats,
|
2020-03-20 07:49:48 -07:00
|
|
|
last_root,
|
|
|
|
last_slot,
|
|
|
|
slots_per_epoch,
|
|
|
|
&|_p| {},
|
2020-12-15 16:50:40 -08:00
|
|
|
&hasher,
|
2020-03-20 07:49:48 -07:00
|
|
|
);
|
2022-01-02 09:10:32 -08:00
|
|
|
assert!(packet.meta.discard());
|
2020-03-20 07:49:48 -07:00
|
|
|
}
|
|
|
|
}
|