Ecosystem/serai
Ecosystem/serai
1
0
Fork 0
mirror of https://github.com/serai-dex/serai.git synced 2024-12-23 12:09:37 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Tweak Heartbeat configuration so LibP2P can be expected to deliver messages within latency window

Browse source
This commit is contained in:
Luke Parker 2023-08-31 01:33:52 -04:00
parent 148bc380fe
commit 3af9dc5d6f
No known key found for this signature in database
3 changed files with 18 additions and 3 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

9
coordinator/src/p2p.rs
View file

@ -187,8 +187,15 @@ impl LibP2p {
// Block size limit + 1 KB of space for signatures/metadata // Block size limit + 1 KB of space for signatures/metadata
const MAX_LIBP2P_MESSAGE_SIZE: usize = tributary::BLOCK_SIZE_LIMIT + 1024; const MAX_LIBP2P_MESSAGE_SIZE: usize = tributary::BLOCK_SIZE_LIMIT + 1024;
let heartbeat_interval = tributary::tendermint::LATENCY_TIME / 2;
let heartbeats_per_block =
usize::try_from(tributary::tendermint::TARGET_BLOCK_TIME / heartbeat_interval).unwrap();
use blake2::{Digest, Blake2s256}; use blake2::{Digest, Blake2s256};
let config = ConfigBuilder::default() let config = ConfigBuilder::default()
.heartbeat_interval(Duration::from_millis(heartbeat_interval.into()))
.history_length(heartbeats_per_block * 2)
.history_gossip(heartbeats_per_block)
.max_transmit_size(MAX_LIBP2P_MESSAGE_SIZE) .max_transmit_size(MAX_LIBP2P_MESSAGE_SIZE)
// We send KeepAlive after 80s // We send KeepAlive after 80s
.idle_timeout(Duration::from_secs(85)) .idle_timeout(Duration::from_secs(85))
@ -340,6 +347,8 @@ impl P2p for LibP2p {
self.0.lock().await.send(msg).expect("broadcast_send closed. are we shutting down?"); self.0.lock().await.send(msg).expect("broadcast_send closed. are we shutting down?");
} }
// TODO: We only have a single handle call this. Differentiate Send/Recv to remove this constant
// lock acquisition?
async fn receive_raw(&self) -> (Self::Id, Vec<u8>) { async fn receive_raw(&self) -> (Self::Id, Vec<u8>) {
self.1.lock().await.recv().await.expect("receive_recv closed. are we shutting down?") self.1.lock().await.recv().await.expect("receive_recv closed. are we shutting down?")
} }

9
coordinator/tributary/src/tendermint/mod.rs
View file

@ -274,6 +274,11 @@ pub struct TendermintNetwork<D: Db, T: TransactionTrait, P: P2p> {
pub(crate) p2p: P, pub(crate) p2p: P,
} }
pub const BLOCK_PROCESSING_TIME: u32 = 999;
pub const LATENCY_TIME: u32 = 1667;
// TODO: Add test asserting this
pub const TARGET_BLOCK_TIME: u32 = BLOCK_PROCESSING_TIME + (3 * LATENCY_TIME);
#[async_trait] #[async_trait]
impl<D: Db, T: TransactionTrait, P: P2p> Network for TendermintNetwork<D, T, P> { impl<D: Db, T: TransactionTrait, P: P2p> Network for TendermintNetwork<D, T, P> {
type ValidatorId = [u8; 32]; type ValidatorId = [u8; 32];
@ -285,8 +290,8 @@ impl<D: Db, T: TransactionTrait, P: P2p> Network for TendermintNetwork<D, T, P>
// The block time is the latency on message delivery (where a message is some piece of data // The block time is the latency on message delivery (where a message is some piece of data
// embedded in a transaction) times three plus the block processing time, hence why it should be // embedded in a transaction) times three plus the block processing time, hence why it should be
// kept low. // kept low.
const BLOCK_PROCESSING_TIME: u32 = 999; const BLOCK_PROCESSING_TIME: u32 = BLOCK_PROCESSING_TIME;
const LATENCY_TIME: u32 = 1667; const LATENCY_TIME: u32 = LATENCY_TIME;
fn signer(&self) -> Arc<Signer> { fn signer(&self) -> Arc<Signer> {
self.signer.clone() self.signer.clone()

3
coordinator/tributary/tendermint/src/lib.rs
View file

@ -189,7 +189,8 @@ impl<N: Network + 'static> TendermintMachine<N> {
// Push it on to the queue. This is done so we only handle one message at a time, and so we // Push it on to the queue. This is done so we only handle one message at a time, and so we
// can handle our own message before broadcasting it. That way, we fail before before // can handle our own message before broadcasting it. That way, we fail before before
// becoming malicious // becoming malicious
self.queue.push_back(msg); // push_front to prioritize our own messages
self.queue.push_front(msg);
} }
} }