Do not wait when empty block is proposed

HoOngEe · HoOngEe · commit 17f983b68d21 · 2020-01-19T15:31:27.000+09:00
We don't need to wait additional times because in case an empty block
is generated. Because the nodes should wait fixed timeout in the next
proposal step.
diff --git a/core/src/consensus/tendermint/mod.rs b/core/src/consensus/tendermint/mod.rs
@@ -45,11 +45,8 @@ use crate::ChainNotify;
 
 /// Timer token representing the consensus step timeouts.
 const ENGINE_TIMEOUT_TOKEN_NONCE_BASE: TimerToken = 23;
-/// Timer token for empty proposal blocks.
-const ENGINE_TIMEOUT_EMPTY_PROPOSAL: TimerToken = 22;
 /// Timer token for broadcasting step state.
 const ENGINE_TIMEOUT_BROADCAST_STEP_STATE: TimerToken = 21;
-
 /// Unit: second
 const ENGINE_TIMEOUT_BROADCAT_STEP_STATE_INTERVAL: u64 = 1;
 
diff --git a/core/src/consensus/tendermint/network.rs b/core/src/consensus/tendermint/network.rs
@@ -38,8 +38,7 @@ use super::worker;
 use crate::consensus::EngineError;
 
 use super::{
-    ENGINE_TIMEOUT_BROADCAST_STEP_STATE, ENGINE_TIMEOUT_BROADCAT_STEP_STATE_INTERVAL, ENGINE_TIMEOUT_EMPTY_PROPOSAL,
-    ENGINE_TIMEOUT_TOKEN_NONCE_BASE,
+    ENGINE_TIMEOUT_BROADCAST_STEP_STATE, ENGINE_TIMEOUT_BROADCAT_STEP_STATE_INTERVAL, ENGINE_TIMEOUT_TOKEN_NONCE_BASE,
 };
 
 pub struct TendermintExtension {
@@ -204,19 +203,11 @@ impl TendermintExtension {
     }
 
     fn set_timer_step(&self, step: Step, view: View, expired_token_nonce: TimerToken) {
-        self.api.clear_timer(ENGINE_TIMEOUT_EMPTY_PROPOSAL).expect("Timer clear succeeds");
         self.api.clear_timer(expired_token_nonce).expect("Timer clear succeeds");
         self.api
             .set_timer_once(expired_token_nonce + 1, self.timeouts.timeout(step, view))
             .expect("Timer set succeeds");
     }
-
-    fn set_timer_empty_proposal(&self, view: View) {
-        self.api.clear_timer(ENGINE_TIMEOUT_EMPTY_PROPOSAL).expect("Timer clear succeeds");
-        self.api
-            .set_timer_once(ENGINE_TIMEOUT_EMPTY_PROPOSAL, self.timeouts.timeout(Step::Propose, view) / 2)
-            .expect("Timer set succeeds");
-    }
 }
 
 impl NetworkExtension<Event> for TendermintExtension {
@@ -403,11 +394,7 @@ impl NetworkExtension<Event> for TendermintExtension {
     }
 
     fn on_timeout(&mut self, token: TimerToken) {
-        debug_assert!(
-            token >= ENGINE_TIMEOUT_TOKEN_NONCE_BASE
-                || token == ENGINE_TIMEOUT_EMPTY_PROPOSAL
-                || token == ENGINE_TIMEOUT_BROADCAST_STEP_STATE
-        );
+        debug_assert!(token >= ENGINE_TIMEOUT_TOKEN_NONCE_BASE || token == ENGINE_TIMEOUT_BROADCAST_STEP_STATE);
         self.inner.send(worker::Event::OnTimeout(token)).unwrap();
     }
 
@@ -443,11 +430,6 @@ impl NetworkExtension<Event> for TendermintExtension {
                 view,
                 expired_token_nonce,
             } => self.set_timer_step(step, view, expired_token_nonce),
-            Event::SetTimerEmptyProposal {
-                view,
-            } => {
-                self.set_timer_empty_proposal(view);
-            }
             Event::BroadcastProposalBlock {
                 signature,
                 view,
@@ -482,9 +464,6 @@ pub enum Event {
         view: View,
         expired_token_nonce: TimerToken,
     },
-    SetTimerEmptyProposal {
-        view: View,
-    },
     BroadcastProposalBlock {
         signature: SchnorrSignature,
         view: View,
diff --git a/core/src/consensus/tendermint/types.rs b/core/src/consensus/tendermint/types.rs
@@ -38,9 +38,6 @@ pub enum TendermintState {
     ProposeWaitImported {
         block: Box<SealedBlock>,
     },
-    ProposeWaitEmptyBlockTimer {
-        block: Box<SealedBlock>,
-    },
     Prevote,
     Precommit,
     Commit {
@@ -63,9 +60,6 @@ impl TendermintState {
             TendermintState::ProposeWaitImported {
                 ..
             } => Step::Propose,
-            TendermintState::ProposeWaitEmptyBlockTimer {
-                ..
-            } => Step::Propose,
             TendermintState::Prevote => Step::Prevote,
             TendermintState::Precommit => Step::Precommit,
             TendermintState::Commit {
@@ -77,15 +71,6 @@ impl TendermintState {
         }
     }
 
-    pub fn is_propose_wait_empty_block_timer(&self) -> bool {
-        match self {
-            TendermintState::ProposeWaitEmptyBlockTimer {
-                ..
-            } => true,
-            _ => false,
-        }
-    }
-
     pub fn is_commit(&self) -> bool {
         match self {
             TendermintState::Commit {
@@ -124,9 +109,6 @@ impl TendermintState {
             TendermintState::ProposeWaitImported {
                 ..
             } => None,
-            TendermintState::ProposeWaitEmptyBlockTimer {
-                ..
-            } => None,
             TendermintState::Prevote => None,
             TendermintState::Precommit => None,
         }
@@ -143,9 +125,6 @@ impl fmt::Debug for TendermintState {
             TendermintState::ProposeWaitImported {
                 block,
             } => write!(f, "TendermintState::ProposeWaitImported({})", block.header().hash()),
-            TendermintState::ProposeWaitEmptyBlockTimer {
-                block,
-            } => write!(f, "TendermintState::ProposeWaitEmptyBlockTimer({})", block.header().hash()),
             TendermintState::Prevote => write!(f, "TendermintState::Prevote"),
             TendermintState::Precommit => write!(f, "TendermintState::Precommit"),
             TendermintState::Commit {
diff --git a/core/src/consensus/tendermint/worker.rs b/core/src/consensus/tendermint/worker.rs
@@ -39,9 +39,7 @@ use super::stake::CUSTOM_ACTION_HANDLER_ID;
 use super::types::{Height, Proposal, Step, TendermintSealView, TendermintState, TwoThirdsMajority, View};
 use super::vote_collector::{DoubleVote, VoteCollector};
 use super::vote_regression_checker::VoteRegressionChecker;
-use super::{
-    ENGINE_TIMEOUT_BROADCAST_STEP_STATE, ENGINE_TIMEOUT_EMPTY_PROPOSAL, ENGINE_TIMEOUT_TOKEN_NONCE_BASE, SEAL_FIELDS,
-};
+use super::{ENGINE_TIMEOUT_BROADCAST_STEP_STATE, ENGINE_TIMEOUT_TOKEN_NONCE_BASE, SEAL_FIELDS};
 use crate::account_provider::AccountProvider;
 use crate::block::*;
 use crate::client::ConsensusClient;
@@ -999,25 +997,10 @@ impl Worker {
                 TendermintState::ProposeWaitImported {
                     block,
                 } => {
-                    if !block.transactions().is_empty() {
-                        cinfo!(ENGINE, "Submitting proposal block {}", block.header().hash());
-                        self.move_to_step(TendermintState::Prevote, false);
-                        self.broadcast_proposal_block(self.view, encoded::Block::new(block.rlp_bytes()));
-                    } else {
-                        ctrace!(ENGINE, "Empty proposal is generated, set timer");
-                        self.step = TendermintState::ProposeWaitEmptyBlockTimer {
-                            block,
-                        };
-                        self.extension
-                            .send(network::Event::SetTimerEmptyProposal {
-                                view: self.view,
-                            })
-                            .unwrap();
-                    }
+                    cinfo!(ENGINE, "Submitting proposal block {}", block.header().hash());
+                    self.move_to_step(TendermintState::Prevote, false);
+                    self.broadcast_proposal_block(self.view, encoded::Block::new(block.rlp_bytes()));
                 }
-                TendermintState::ProposeWaitEmptyBlockTimer {
-                    ..
-                } => unreachable!(),
                 _ => {}
             };
         } else if current_height < height {
@@ -1287,35 +1270,6 @@ impl Worker {
     }
 
     fn on_timeout(&mut self, token: usize) {
-        // Timeout from empty block generation
-        if token == ENGINE_TIMEOUT_EMPTY_PROPOSAL {
-            let block = if self.step.is_propose_wait_empty_block_timer() {
-                let previous = mem::replace(&mut self.step, TendermintState::Propose);
-                match previous {
-                    TendermintState::ProposeWaitEmptyBlockTimer {
-                        block,
-                    } => block,
-                    _ => unreachable!(),
-                }
-            } else {
-                cwarn!(ENGINE, "Empty proposal timer was not cleared.");
-                return
-            };
-
-            // When self.height != block.header().number() && "propose timeout" is already called,
-            // the state is stuck and can't move to Prevote. We should change the step to Prevote.
-            self.move_to_step(TendermintState::Prevote, false);
-            if self.height == block.header().number() {
-                cdebug!(ENGINE, "Empty proposal timer is finished, go to the prevote step and broadcast the block");
-                cinfo!(ENGINE, "Submitting proposal block {}", block.header().hash());
-                self.broadcast_proposal_block(self.view, encoded::Block::new(block.rlp_bytes()));
-            } else {
-                cwarn!(ENGINE, "Empty proposal timer was for previous height.");
-            }
-
-            return
-        }
-
         if token == ENGINE_TIMEOUT_BROADCAST_STEP_STATE {
             if let Some(votes_received) = self.votes_received.borrow_if_mutated() {
                 self.broadcast_state(
@@ -1350,12 +1304,6 @@ impl Worker {
                 cwarn!(ENGINE, "Propose timed out but still waiting for the block imported");
                 return
             }
-            TendermintState::ProposeWaitEmptyBlockTimer {
-                ..
-            } => {
-                cwarn!(ENGINE, "Propose timed out but still waiting for the empty block");
-                return
-            }
             TendermintState::Prevote if self.has_enough_any_votes() => {
                 cinfo!(ENGINE, "Prevote timeout.");
                 TendermintState::Precommit
