2018-05-29 10:18:12 -07:00
|
|
|
//! The `fetch_stage` batches input from a UDP socket and sends it to a channel.
|
|
|
|
|
2021-03-03 10:23:05 -08:00
|
|
|
use crate::banking_stage::HOLD_TRANSACTIONS_SLOT_OFFSET;
|
2019-04-22 19:49:32 -07:00
|
|
|
use crate::result::{Error, Result};
|
2019-05-17 07:00:06 -07:00
|
|
|
use solana_metrics::{inc_new_counter_debug, inc_new_counter_info};
|
2020-03-17 23:30:23 -07:00
|
|
|
use solana_perf::packet::PacketsRecycler;
|
2019-11-04 20:13:43 -08:00
|
|
|
use solana_perf::recycler::Recycler;
|
2021-06-04 08:23:06 -07:00
|
|
|
use solana_poh::poh_recorder::PohRecorder;
|
2019-09-06 14:30:56 -07:00
|
|
|
use solana_sdk::clock::DEFAULT_TICKS_PER_SLOT;
|
2020-03-17 23:30:23 -07:00
|
|
|
use solana_streamer::streamer::{self, PacketReceiver, PacketSender};
|
2018-05-29 10:18:12 -07:00
|
|
|
use std::net::UdpSocket;
|
2019-03-04 19:02:03 -08:00
|
|
|
use std::sync::atomic::AtomicBool;
|
2019-04-22 19:49:32 -07:00
|
|
|
use std::sync::mpsc::{channel, RecvTimeoutError};
|
|
|
|
use std::sync::{Arc, Mutex};
|
|
|
|
use std::thread::{self, Builder, JoinHandle};
|
2018-05-29 10:18:12 -07:00
|
|
|
|
|
|
|
pub struct FetchStage {
|
2018-07-03 21:14:08 -07:00
|
|
|
thread_hdls: Vec<JoinHandle<()>>,
|
2018-05-29 10:18:12 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
impl FetchStage {
|
2018-12-07 19:01:28 -08:00
|
|
|
#[allow(clippy::new_ret_no_self)]
|
2019-03-08 14:59:11 -08:00
|
|
|
pub fn new(
|
|
|
|
sockets: Vec<UdpSocket>,
|
2019-07-30 14:50:02 -07:00
|
|
|
tpu_forwards_sockets: Vec<UdpSocket>,
|
2019-03-08 14:59:11 -08:00
|
|
|
exit: &Arc<AtomicBool>,
|
2019-04-22 19:49:32 -07:00
|
|
|
poh_recorder: &Arc<Mutex<PohRecorder>>,
|
2021-02-26 09:15:45 -08:00
|
|
|
coalesce_ms: u64,
|
2019-03-08 14:59:11 -08:00
|
|
|
) -> (Self, PacketReceiver) {
|
2019-01-31 15:51:29 -08:00
|
|
|
let (sender, receiver) = channel();
|
2019-03-08 14:59:11 -08:00
|
|
|
(
|
2021-02-24 00:15:58 -08:00
|
|
|
Self::new_with_sender(
|
|
|
|
sockets,
|
|
|
|
tpu_forwards_sockets,
|
|
|
|
exit,
|
|
|
|
&sender,
|
2021-06-18 06:34:46 -07:00
|
|
|
poh_recorder,
|
2021-02-26 09:15:45 -08:00
|
|
|
coalesce_ms,
|
2021-02-24 00:15:58 -08:00
|
|
|
),
|
2019-03-08 14:59:11 -08:00
|
|
|
receiver,
|
|
|
|
)
|
2019-01-31 15:51:29 -08:00
|
|
|
}
|
|
|
|
pub fn new_with_sender(
|
|
|
|
sockets: Vec<UdpSocket>,
|
2019-07-30 14:50:02 -07:00
|
|
|
tpu_forwards_sockets: Vec<UdpSocket>,
|
2019-03-04 19:53:50 -08:00
|
|
|
exit: &Arc<AtomicBool>,
|
2019-01-31 15:51:29 -08:00
|
|
|
sender: &PacketSender,
|
2019-04-22 19:49:32 -07:00
|
|
|
poh_recorder: &Arc<Mutex<PohRecorder>>,
|
2021-02-26 09:15:45 -08:00
|
|
|
coalesce_ms: u64,
|
2019-01-31 15:51:29 -08:00
|
|
|
) -> Self {
|
2018-09-06 14:13:40 -07:00
|
|
|
let tx_sockets = sockets.into_iter().map(Arc::new).collect();
|
2019-07-30 14:50:02 -07:00
|
|
|
let tpu_forwards_sockets = tpu_forwards_sockets.into_iter().map(Arc::new).collect();
|
2019-04-22 19:49:32 -07:00
|
|
|
Self::new_multi_socket(
|
|
|
|
tx_sockets,
|
2019-07-30 14:50:02 -07:00
|
|
|
tpu_forwards_sockets,
|
2019-04-22 19:49:32 -07:00
|
|
|
exit,
|
2021-06-18 06:34:46 -07:00
|
|
|
sender,
|
|
|
|
poh_recorder,
|
2021-02-26 09:15:45 -08:00
|
|
|
coalesce_ms,
|
2019-04-22 19:49:32 -07:00
|
|
|
)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn handle_forwarded_packets(
|
|
|
|
recvr: &PacketReceiver,
|
|
|
|
sendr: &PacketSender,
|
|
|
|
poh_recorder: &Arc<Mutex<PohRecorder>>,
|
|
|
|
) -> Result<()> {
|
|
|
|
let msgs = recvr.recv()?;
|
|
|
|
let mut len = msgs.packets.len();
|
|
|
|
let mut batch = vec![msgs];
|
|
|
|
while let Ok(more) = recvr.try_recv() {
|
|
|
|
len += more.packets.len();
|
|
|
|
batch.push(more);
|
2019-10-14 13:32:29 -07:00
|
|
|
// Read at most 1K transactions in a loop
|
|
|
|
if len > 1024 {
|
|
|
|
break;
|
|
|
|
}
|
2019-04-22 19:49:32 -07:00
|
|
|
}
|
|
|
|
|
2021-03-03 10:23:05 -08:00
|
|
|
if poh_recorder
|
|
|
|
.lock()
|
|
|
|
.unwrap()
|
|
|
|
.would_be_leader(HOLD_TRANSACTIONS_SLOT_OFFSET.saturating_mul(DEFAULT_TICKS_PER_SLOT))
|
|
|
|
{
|
2019-05-17 07:00:06 -07:00
|
|
|
inc_new_counter_debug!("fetch_stage-honor_forwards", len);
|
2019-04-22 19:49:32 -07:00
|
|
|
for packets in batch {
|
|
|
|
if sendr.send(packets).is_err() {
|
2021-06-18 11:47:40 -07:00
|
|
|
return Err(Error::Send);
|
2019-04-22 19:49:32 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
inc_new_counter_info!("fetch_stage-discard_forwards", len);
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(())
|
2018-06-13 21:52:23 -07:00
|
|
|
}
|
2019-03-08 15:47:53 -08:00
|
|
|
|
2019-01-24 12:46:40 -08:00
|
|
|
fn new_multi_socket(
|
2018-08-28 16:32:40 -07:00
|
|
|
sockets: Vec<Arc<UdpSocket>>,
|
2019-07-30 14:50:02 -07:00
|
|
|
tpu_forwards_sockets: Vec<Arc<UdpSocket>>,
|
2019-03-04 19:53:50 -08:00
|
|
|
exit: &Arc<AtomicBool>,
|
2019-01-31 15:51:29 -08:00
|
|
|
sender: &PacketSender,
|
2019-04-22 19:49:32 -07:00
|
|
|
poh_recorder: &Arc<Mutex<PohRecorder>>,
|
2021-02-26 09:15:45 -08:00
|
|
|
coalesce_ms: u64,
|
2019-01-31 15:51:29 -08:00
|
|
|
) -> Self {
|
2021-04-07 08:15:38 -07:00
|
|
|
let recycler: PacketsRecycler = Recycler::warmed(1000, 1024);
|
2019-11-07 19:48:33 -08:00
|
|
|
|
2019-06-27 00:32:32 -07:00
|
|
|
let tpu_threads = sockets.into_iter().map(|socket| {
|
|
|
|
streamer::receiver(
|
|
|
|
socket,
|
2021-06-18 06:34:46 -07:00
|
|
|
exit,
|
2019-06-27 00:32:32 -07:00
|
|
|
sender.clone(),
|
|
|
|
recycler.clone(),
|
|
|
|
"fetch_stage",
|
2021-02-26 09:15:45 -08:00
|
|
|
coalesce_ms,
|
2021-06-14 07:10:04 -07:00
|
|
|
true,
|
2019-06-27 00:32:32 -07:00
|
|
|
)
|
|
|
|
});
|
2019-03-08 15:47:53 -08:00
|
|
|
|
2019-04-22 19:49:32 -07:00
|
|
|
let (forward_sender, forward_receiver) = channel();
|
2019-07-30 14:50:02 -07:00
|
|
|
let tpu_forwards_threads = tpu_forwards_sockets.into_iter().map(|socket| {
|
|
|
|
streamer::receiver(
|
|
|
|
socket,
|
2021-06-18 06:34:46 -07:00
|
|
|
exit,
|
2019-07-30 14:50:02 -07:00
|
|
|
forward_sender.clone(),
|
|
|
|
recycler.clone(),
|
|
|
|
"fetch_forward_stage",
|
2021-02-26 09:15:45 -08:00
|
|
|
coalesce_ms,
|
2021-06-14 07:10:04 -07:00
|
|
|
true,
|
2019-07-30 14:50:02 -07:00
|
|
|
)
|
|
|
|
});
|
2019-04-22 19:49:32 -07:00
|
|
|
|
|
|
|
let sender = sender.clone();
|
|
|
|
let poh_recorder = poh_recorder.clone();
|
|
|
|
|
|
|
|
let fwd_thread_hdl = Builder::new()
|
|
|
|
.name("solana-fetch-stage-fwd-rcvr".to_string())
|
|
|
|
.spawn(move || loop {
|
|
|
|
if let Err(e) =
|
|
|
|
Self::handle_forwarded_packets(&forward_receiver, &sender, &poh_recorder)
|
|
|
|
{
|
|
|
|
match e {
|
2021-06-18 11:47:40 -07:00
|
|
|
Error::RecvTimeout(RecvTimeoutError::Disconnected) => break,
|
|
|
|
Error::RecvTimeout(RecvTimeoutError::Timeout) => (),
|
|
|
|
Error::Recv(_) => break,
|
|
|
|
Error::Send => break,
|
2019-04-22 19:49:32 -07:00
|
|
|
_ => error!("{:?}", e),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
})
|
|
|
|
.unwrap();
|
2018-05-29 10:18:12 -07:00
|
|
|
|
2019-07-30 14:50:02 -07:00
|
|
|
let mut thread_hdls: Vec<_> = tpu_threads.chain(tpu_forwards_threads).collect();
|
2019-04-22 19:49:32 -07:00
|
|
|
thread_hdls.push(fwd_thread_hdl);
|
2019-03-04 19:02:03 -08:00
|
|
|
Self { thread_hdls }
|
2018-05-29 10:18:12 -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(())
|
|
|
|
}
|
|
|
|
}
|