From 697565c97ac59fab0f240313352766d45b4f4e97 Mon Sep 17 00:00:00 2001 From: Vladimir Komendantskiy Date: Tue, 6 Nov 2018 17:22:28 +0000 Subject: [PATCH] Move sender queue impls out of Honey Badger algorithms (#321) * moved SenderQueueable impls out of HB algorithm modules and into sender_queue * added sender_queue::honey_badger --- src/dynamic_honey_badger/mod.rs | 2 - src/dynamic_honey_badger/sender_queueable.rs | 84 ------------------ src/honey_badger/mod.rs | 2 - src/queueing_honey_badger/mod.rs | 2 - src/queueing_honey_badger/sender_queueable.rs | 18 ---- src/sender_queue/dynamic_honey_badger.rs | 88 ++++++++++++++++++- .../honey_badger.rs} | 4 +- src/sender_queue/mod.rs | 6 +- src/sender_queue/queueing_honey_badger.rs | 13 ++- 9 files changed, 103 insertions(+), 116 deletions(-) delete mode 100644 src/dynamic_honey_badger/sender_queueable.rs delete mode 100644 src/queueing_honey_badger/sender_queueable.rs rename src/{honey_badger/sender_queueable.rs => sender_queue/honey_badger.rs} (94%) diff --git a/src/dynamic_honey_badger/mod.rs b/src/dynamic_honey_badger/mod.rs index 7cbc2d0..43e0dd7 100644 --- a/src/dynamic_honey_badger/mod.rs +++ b/src/dynamic_honey_badger/mod.rs @@ -72,8 +72,6 @@ mod dynamic_honey_badger; mod error; mod votes; -pub mod sender_queueable; - use std::cmp::Ordering; use std::collections::BTreeMap; diff --git a/src/dynamic_honey_badger/sender_queueable.rs b/src/dynamic_honey_badger/sender_queueable.rs deleted file mode 100644 index 06238b8..0000000 --- a/src/dynamic_honey_badger/sender_queueable.rs +++ /dev/null @@ -1,84 +0,0 @@ -use rand::Rand; -use serde::{de::DeserializeOwned, Serialize}; - -use super::{Batch, Change, ChangeState, DynamicHoneyBadger, Epoch, Message, NodeChange}; -use sender_queue::{ - SenderQueueableDistAlgorithm, SenderQueueableEpoch, SenderQueueableMessage, - SenderQueueableOutput, -}; -use {Contribution, Epoched, NodeIdT}; - -impl SenderQueueableOutput> for Batch -where - C: Contribution, - N: NodeIdT + Rand, -{ - fn added_node(&self) -> Option { - if let ChangeState::InProgress(Change::NodeChange(NodeChange::Add(ref id, _))) = self.change - { - // Register the new node to send broadcast messages to it from now on. - Some(id.clone()) - } else { - None - } - } - - fn next_epoch(&self) -> (u64, u64) { - let epoch = self.epoch; - let era = self.era; - if self.change == ChangeState::None { - (era, epoch - era + 1) - } else { - (epoch + 1, 0) - } - } -} - -impl SenderQueueableMessage for Message -where - N: Rand, -{ - fn is_accepted(&self, (them_era, them): (u64, u64), max_future_epochs: u64) -> bool { - let Epoch(era, us) = self.epoch(); - if era != them_era { - return false; - } - if let Some(us) = us { - them <= us && us <= them + max_future_epochs - } else { - true - } - } - - fn is_obsolete(&self, (them_era, them): (u64, u64)) -> bool { - let Epoch(era, us) = self.epoch(); - if era < them_era { - return true; - } - if let Some(us) = us { - era == them_era && us < them - } else { - false - } - } -} - -impl SenderQueueableEpoch for Epoch { - fn spanning_epochs(&self) -> Vec { - if let Epoch(era, Some(_)) = *self { - vec![Epoch(era, None)] - } else { - vec![] - } - } -} - -impl SenderQueueableDistAlgorithm for DynamicHoneyBadger -where - C: Contribution + Serialize + DeserializeOwned, - N: NodeIdT + Serialize + DeserializeOwned + Rand, -{ - fn max_future_epochs(&self) -> u64 { - self.max_future_epochs() - } -} diff --git a/src/honey_badger/mod.rs b/src/honey_badger/mod.rs index 5d59123..87d6cc7 100644 --- a/src/honey_badger/mod.rs +++ b/src/honey_badger/mod.rs @@ -29,8 +29,6 @@ mod error; mod honey_badger; mod message; -pub mod sender_queueable; - pub use self::batch::Batch; pub use self::builder::HoneyBadgerBuilder; pub use self::error::{Error, ErrorKind, Result}; diff --git a/src/queueing_honey_badger/mod.rs b/src/queueing_honey_badger/mod.rs index ab46423..806a174 100644 --- a/src/queueing_honey_badger/mod.rs +++ b/src/queueing_honey_badger/mod.rs @@ -22,8 +22,6 @@ //! entries, any two nodes will likely make almost disjoint contributions instead of proposing //! the same transaction multiple times. -pub mod sender_queueable; - use std::fmt::{self, Display}; use std::marker::PhantomData; use std::{cmp, iter}; diff --git a/src/queueing_honey_badger/sender_queueable.rs b/src/queueing_honey_badger/sender_queueable.rs deleted file mode 100644 index c9791c4..0000000 --- a/src/queueing_honey_badger/sender_queueable.rs +++ /dev/null @@ -1,18 +0,0 @@ -use rand::Rand; -use serde::{de::DeserializeOwned, Serialize}; - -use super::QueueingHoneyBadger; -use sender_queue::SenderQueueableDistAlgorithm; -use transaction_queue::TransactionQueue; -use {Contribution, NodeIdT}; - -impl SenderQueueableDistAlgorithm for QueueingHoneyBadger -where - T: Contribution + Serialize + DeserializeOwned + Clone, - N: NodeIdT + Serialize + DeserializeOwned + Rand, - Q: TransactionQueue, -{ - fn max_future_epochs(&self) -> u64 { - self.dyn_hb.max_future_epochs() - } -} diff --git a/src/sender_queue/dynamic_honey_badger.rs b/src/sender_queue/dynamic_honey_badger.rs index 36d0493..67af96a 100644 --- a/src/sender_queue/dynamic_honey_badger.rs +++ b/src/sender_queue/dynamic_honey_badger.rs @@ -4,9 +4,91 @@ use crypto::PublicKey; use rand::Rand; use serde::{de::DeserializeOwned, Serialize}; -use super::{SenderQueue, Step}; -use dynamic_honey_badger::{Change, DynamicHoneyBadger}; -use {Contribution, NodeIdT}; +use super::{ + SenderQueue, SenderQueueableDistAlgorithm, SenderQueueableEpoch, SenderQueueableMessage, + SenderQueueableOutput, Step, +}; +use {Contribution, Epoched, NodeIdT}; + +use dynamic_honey_badger::{ + Batch, Change, ChangeState, DynamicHoneyBadger, Epoch, Message, NodeChange, +}; + +impl SenderQueueableOutput> for Batch +where + C: Contribution, + N: NodeIdT + Rand, +{ + fn added_node(&self) -> Option { + if let ChangeState::InProgress(Change::NodeChange(NodeChange::Add(ref id, _))) = + self.change() + { + // Register the new node to send broadcast messages to it from now on. + Some(id.clone()) + } else { + None + } + } + + fn next_epoch(&self) -> (u64, u64) { + let epoch = self.epoch(); + let era = self.era(); + if *self.change() == ChangeState::None { + (era, epoch - era + 1) + } else { + (epoch + 1, 0) + } + } +} + +impl SenderQueueableMessage for Message +where + N: Rand, +{ + fn is_accepted(&self, (them_era, them): (u64, u64), max_future_epochs: u64) -> bool { + let Epoch(era, us) = self.epoch(); + if era != them_era { + return false; + } + if let Some(us) = us { + them <= us && us <= them + max_future_epochs + } else { + true + } + } + + fn is_obsolete(&self, (them_era, them): (u64, u64)) -> bool { + let Epoch(era, us) = self.epoch(); + if era < them_era { + return true; + } + if let Some(us) = us { + era == them_era && us < them + } else { + false + } + } +} + +impl SenderQueueableEpoch for Epoch { + fn spanning_epochs(&self) -> Vec { + if let Epoch(era, Some(_)) = *self { + vec![Epoch(era, None)] + } else { + vec![] + } + } +} + +impl SenderQueueableDistAlgorithm for DynamicHoneyBadger +where + C: Contribution + Serialize + DeserializeOwned, + N: NodeIdT + Serialize + DeserializeOwned + Rand, +{ + fn max_future_epochs(&self) -> u64 { + self.max_future_epochs() + } +} type Result = super::Result>, DynamicHoneyBadger>; diff --git a/src/honey_badger/sender_queueable.rs b/src/sender_queue/honey_badger.rs similarity index 94% rename from src/honey_badger/sender_queueable.rs rename to src/sender_queue/honey_badger.rs index d84878b..9529ce1 100644 --- a/src/honey_badger/sender_queueable.rs +++ b/src/sender_queue/honey_badger.rs @@ -1,11 +1,11 @@ use rand::Rand; use serde::{de::DeserializeOwned, Serialize}; -use super::{Batch, HoneyBadger, Message}; -use sender_queue::{ +use super::{ SenderQueueableDistAlgorithm, SenderQueueableEpoch, SenderQueueableMessage, SenderQueueableOutput, }; +use honey_badger::{Batch, HoneyBadger, Message}; use {Contribution, Epoched, NodeIdT}; impl SenderQueueableOutput> for Batch diff --git a/src/sender_queue/mod.rs b/src/sender_queue/mod.rs index 992d24a..b2dd2bc 100644 --- a/src/sender_queue/mod.rs +++ b/src/sender_queue/mod.rs @@ -5,9 +5,11 @@ //! epoch matches the epoch of the message. Thus no queueing is required for incoming messages since //! any incoming messages with non-matching epochs can be safely discarded. -mod dynamic_honey_badger; mod message; -mod queueing_honey_badger; + +pub mod dynamic_honey_badger; +pub mod honey_badger; +pub mod queueing_honey_badger; use std::collections::BTreeMap; use std::fmt::Debug; diff --git a/src/sender_queue/queueing_honey_badger.rs b/src/sender_queue/queueing_honey_badger.rs index 4918347..05e6203 100644 --- a/src/sender_queue/queueing_honey_badger.rs +++ b/src/sender_queue/queueing_honey_badger.rs @@ -4,11 +4,22 @@ use crypto::PublicKey; use rand::Rand; use serde::{de::DeserializeOwned, Serialize}; -use super::{SenderQueue, Step}; +use super::{SenderQueue, SenderQueueableDistAlgorithm, Step}; use queueing_honey_badger::{Change, QueueingHoneyBadger}; use transaction_queue::TransactionQueue; use {Contribution, NodeIdT}; +impl SenderQueueableDistAlgorithm for QueueingHoneyBadger +where + T: Contribution + Serialize + DeserializeOwned + Clone, + N: NodeIdT + Serialize + DeserializeOwned + Rand, + Q: TransactionQueue, +{ + fn max_future_epochs(&self) -> u64 { + self.dyn_hb().max_future_epochs() + } +} + type Result = super::Result>, QueueingHoneyBadger>;