Implement PriorityCollector

Author: HoOngEe

core/src/consensus/mod.rs

@@ -31,6 +31,7 @@ pub use self::cuckoo::Cuckoo;
 pub use self::null_engine::NullEngine;
 pub use self::simple_poa::SimplePoA;
 pub use self::solo::Solo;
+pub use self::sortition::vrf_sortition::{Priority, PriorityInfo, VRFSortition};
 pub use self::tendermint::{
     ConsensusMessage, Height, Step, Tendermint, TendermintParams, TimeGapParams, View, VoteOn, VoteStep,
 };

core/src/consensus/sortition/vrf_sortition.rs

@@ -36,7 +36,7 @@ pub struct VRFSortition {
     pub vrf_inst: Arc<RwLock<ECVRF>>,
 }
 
-#[derive(Eq, PartialEq, Debug, RlpEncodable, RlpDecodable)]
+#[derive(Eq, PartialEq, Clone, Debug, RlpEncodable, RlpDecodable)]
 pub struct PriorityInfo {
     priority: Priority,
     sub_user_idx: u64,

core/src/consensus/tendermint/message.rs

@@ -27,6 +27,14 @@ pub use super::super::sortition::PriorityMessage;
 use super::super::BitSet;
 use super::{Height, Step, View};
 
+/// Step for the sortition round.
+/// FIXME: It has a large overlap with the previous VoteStep.
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Hash, RlpDecodable, RlpEncodable)]
+pub struct SortitionRound {
+    pub height: Height,
+    pub view: View,
+}
+
 /// Complete step of the consensus process.
 #[derive(Debug, PartialEq, Eq, Clone, Copy, Hash, RlpDecodable, RlpEncodable)]
 pub struct VoteStep {
@@ -73,6 +81,18 @@ impl Ord for VoteStep {
     }
 }
 
+impl PartialOrd for SortitionRound {
+    fn partial_cmp(&self, other: &SortitionRound) -> Option<cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for SortitionRound {
+    fn cmp(&self, other: &SortitionRound) -> cmp::Ordering {
+        (self.height, self.view).cmp(&(other.height, other.view))
+    }
+}
+
 const MESSAGE_ID_CONSENSUS_MESSAGE: u8 = 0x01;
 const MESSAGE_ID_PROPOSAL_BLOCK: u8 = 0x02;
 const MESSAGE_ID_STEP_STATE: u8 = 0x03;

core/src/consensus/tendermint/mod.rs

@@ -20,6 +20,7 @@ mod engine;
 mod message;
 mod network;
 mod params;
+pub mod sortition_info_collector;
 pub mod types;
 pub mod vote_collector;
 mod vote_regression_checker;
@@ -35,7 +36,7 @@ use ctimer::TimerToken;
 use parking_lot::RwLock;
 
 use self::chain_notify::TendermintChainNotify;
-pub use self::message::{ConsensusMessage, VoteOn, VoteStep};
+pub use self::message::{ConsensusMessage, PriorityMessage, SortitionRound, VoteOn, VoteStep};
 pub use self::params::{TendermintParams, TimeGapParams, TimeoutParams};
 pub use self::types::{Height, Step, View};
 use super::{stake, ValidatorSet};

core/src/consensus/tendermint/sortition_info_collector.rs

@@ -0,0 +1,163 @@
+// Copyright 2019 Kodebox, Inc.
+// This file is part of CodeChain.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either verion 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+use std::cmp::Ordering;
+use std::collections::{BTreeMap, BinaryHeap};
+
+use rug::{integer::Order, Integer};
+
+use super::{PriorityMessage, SortitionRound};
+use crate::consensus::PriorityInfo;
+
+/// Storing Priorities
+#[derive(Default)]
+pub struct SortitionInfoCollector {
+    priorities: BTreeMap<SortitionRound, BinaryHeap<SortitionInfo>>,
+}
+
+#[cfg_attr(test, derive(Debug))]
+#[derive(Eq, PartialEq)]
+pub struct SortitionInfo {
+    priority_info: PriorityInfo,
+    signer_idx: usize,
+}
+
+impl Ord for SortitionInfo {
+    fn cmp(&self, other: &Self) -> Ordering {
+        let self_as_int = Integer::from_digits(&self.priority_info.priority(), Order::MsfBe);
+        let other_as_int = Integer::from_digits(&other.priority_info.priority(), Order::MsfBe);
+
+        self_as_int.cmp(&other_as_int)
+    }
+}
+
+impl PartialOrd for SortitionInfo {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl SortitionInfo {
+    pub fn from_message_and_idx(message: &PriorityMessage, signer_idx: usize) -> Self {
+        Self {
+            priority_info: message.info.clone(),
+            signer_idx,
+        }
+    }
+}
+
+impl SortitionInfoCollector {
+    pub fn insert(&mut self, message: &PriorityMessage, signer_idx: usize, round: SortitionRound) {
+        let info_summary = SortitionInfo::from_message_and_idx(message, signer_idx);
+        self.priorities.entry(round).or_insert_with(Default::default).push(info_summary);
+    }
+
+    pub fn get_highest_priority(&mut self, round: SortitionRound) -> Option<SortitionInfo> {
+        self.priorities.entry(round).or_default().pop()
+    }
+
+    /// Throw away priorities older than the given round.
+    pub fn throw_away_old(&mut self, round: &SortitionRound) {
+        let new_collector = self.priorities.split_off(round);
+        assert!(!new_collector.is_empty());
+        self.priorities = new_collector;
+    }
+}
+
+#[cfg(test)]
+mod sortition_info_collector_tests {
+    use super::*;
+    use crate::consensus::Priority;
+
+    fn generate_priority_info_with_priority(priority: Priority) -> PriorityInfo {
+        PriorityInfo::create_from_members(priority, 0, vec![], vec![])
+    }
+
+    #[test]
+    fn compare_sortition_info() {
+        let greater_priority_info_summary = SortitionInfo {
+            priority_info: generate_priority_info_with_priority(0xffu64.into()),
+            signer_idx: 0,
+        };
+        let less_priority_info_summary = SortitionInfo {
+            priority_info: generate_priority_info_with_priority(0x7fu64.into()),
+            signer_idx: 1,
+        };
+        assert!(greater_priority_info_summary > less_priority_info_summary);
+    }
+
+    #[test]
+    fn compare_sortition_info2() {
+        let greater_priority_info_summary = SortitionInfo {
+            priority_info: generate_priority_info_with_priority(0x55555544u64.into()),
+            signer_idx: 0,
+        };
+        let less_priority_info_summary = SortitionInfo {
+            priority_info: generate_priority_info_with_priority(0x55555523u64.into()),
+            signer_idx: 22,
+        };
+        assert!(greater_priority_info_summary > less_priority_info_summary);
+    }
+
+    fn add_fixed_priorities(collector: &mut SortitionInfoCollector, round: SortitionRound) {
+        let priority_messages = [0x55u64, 0xffu64, 0x44u64, 0xeeu64].into_iter().map(|priority| {
+            let info = generate_priority_info_with_priority((*priority).into());
+            PriorityMessage {
+                seed: 0xffffu64.into(),
+                info,
+            }
+        });
+        priority_messages
+            .zip([1, 2, 3, 4].iter())
+            .for_each(|(message, signer_idx)| collector.insert(&message, *signer_idx, round));
+    }
+
+    #[test]
+    fn insert_and_get_highest() {
+        let mut collector: SortitionInfoCollector = Default::default();
+        let round = SortitionRound {
+            height: 1,
+            view: 0,
+        };
+        add_fixed_priorities(&mut collector, round);
+        assert_eq!(collector.get_highest_priority(round).unwrap(), SortitionInfo {
+            priority_info: generate_priority_info_with_priority(0xffu64.into()),
+            signer_idx: 2,
+        });
+    }
+
+    #[test]
+    fn throw_away_old() {
+        let mut collector: SortitionInfoCollector = Default::default();
+        let rounds = [(1, 0), (3, 1), (5, 2), (100, 7), (0, 8)].into_iter().map(|(height, view)| SortitionRound {
+            height: *height,
+            view: *view,
+        });
+        rounds.clone().for_each(|round| add_fixed_priorities(&mut collector, round));
+        let target_round = SortitionRound {
+            height: 5,
+            view: 2,
+        };
+        collector.throw_away_old(&target_round);
+        rounds
+            .clone()
+            .filter(|round| round >= &target_round)
+            .for_each(|round_gte| assert!(collector.get_highest_priority(round_gte).is_some()));
+        rounds
+            .filter(|round| round < &target_round)
+            .for_each(|round_lt| assert!(collector.get_highest_priority(round_lt).is_none()))
+    }
+}