Skip to content

Commit

Permalink
optimize consensus code,modify return type when no error msg
Browse files Browse the repository at this point in the history
  • Loading branch information
@xiemylogos
xiemylogos committed Mar 25, 2019
1 parent 0c8b68e commit cb50c3b
Show file tree
Hide file tree
Showing 12 changed files with 141 additions and 284 deletions.
19 changes: 8 additions & 11 deletions consensus/vbft/block_pool.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -249,40 +249,39 @@ func (pool *BlockPool) setProposalEndorsed(proposal *blockProposalMsg, forEmpty
return nil
}

func (pool *BlockPool) addBlockEndorsementLocked(blkNum uint32, endorser uint32, eSig *CandidateEndorseSigInfo) error {
func (pool *BlockPool) addBlockEndorsementLocked(blkNum uint32, endorser uint32, eSig *CandidateEndorseSigInfo) {
candidate := pool.getCandidateInfoLocked(blkNum)

if eSigs, present := candidate.EndorseSigs[endorser]; present {
for _, eSig := range eSigs {
if eSig.ForEmpty {
// has endorsed for empty, ignore new endorsement
return nil
return
}
}
if eSig.ForEmpty {
// add empty endorsement
candidate.EndorseSigs[endorser] = append(eSigs, eSig)
return nil
return
}

// check dup endorsement
for _, esig := range eSigs {
if esig.EndorsedProposer == eSig.EndorsedProposer {
return nil
return
}
}
candidate.EndorseSigs[endorser] = append(eSigs, eSig)
} else {
candidate.EndorseSigs[endorser] = []*CandidateEndorseSigInfo{eSig}
}

return nil
return
}

//
// add endorsement msg to CandidateInfo
//
func (pool *BlockPool) newBlockEndorsement(msg *blockEndorseMsg) error {
func (pool *BlockPool) newBlockEndorsement(msg *blockEndorseMsg) {
pool.lock.Lock()
defer pool.lock.Unlock()

Expand All @@ -291,7 +290,7 @@ func (pool *BlockPool) newBlockEndorsement(msg *blockEndorseMsg) error {
Signature: msg.EndorserSig,
ForEmpty: msg.EndorseForEmpty,
}
return pool.addBlockEndorsementLocked(msg.GetBlockNum(), msg.Endorser, eSig)
pool.addBlockEndorsementLocked(msg.GetBlockNum(), msg.Endorser, eSig)
}

//
Expand Down Expand Up @@ -462,9 +461,7 @@ func (pool *BlockPool) newBlockCommitment(msg *blockCommitMsg) error {
Signature: sig,
ForEmpty: msg.CommitForEmpty,
}
if err := pool.addBlockEndorsementLocked(blkNum, endorser, eSig); err != nil {
return fmt.Errorf("failed to verify endorse sig from %d: %s", endorser, err)
}
pool.addBlockEndorsementLocked(blkNum, endorser, eSig)
}

// add committer sig
Expand Down
92 changes: 41 additions & 51 deletions consensus/vbft/event_timer.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -119,7 +119,7 @@ func (self *EventTimer) stop() {
self.normalTimers = make(map[uint32]*time.Timer)
}

func (self *EventTimer) StartTimer(Idx uint32, timeout time.Duration) error {
func (self *EventTimer) StartTimer(Idx uint32, timeout time.Duration) {
self.lock.Lock()
defer self.lock.Unlock()

Expand All @@ -139,19 +139,16 @@ func (self *EventTimer) StartTimer(Idx uint32, timeout time.Duration) error {
blockNum: Idx,
}
})

return nil
}

func (self *EventTimer) CancelTimer(idx uint32) error {
func (self *EventTimer) CancelTimer(idx uint32) {
self.lock.Lock()
defer self.lock.Unlock()

if t, present := self.normalTimers[idx]; present {
t.Stop()
delete(self.normalTimers, idx)
}
return nil
}

func (self *EventTimer) getEventTimeout(evtType TimerEventType) time.Duration {
Expand Down Expand Up @@ -190,7 +187,7 @@ func (self *EventTimer) getEventTimeout(evtType TimerEventType) time.Duration {
//
// internal helper, should call with lock held
//
func (self *EventTimer) startEventTimer(evtType TimerEventType, blockNum uint32) error {
func (self *EventTimer) startEventTimer(evtType TimerEventType, blockNum uint32) {
timers := self.eventTimers[evtType]
if t, present := timers[blockNum]; present {
t.Stop()
Expand All @@ -208,124 +205,120 @@ func (self *EventTimer) startEventTimer(evtType TimerEventType, blockNum uint32)
blockNum: blockNum,
}
})

return nil
}

//
// internal helper, should call with lock held
//
func (self *EventTimer) cancelEventTimer(evtType TimerEventType, blockNum uint32) error {
func (self *EventTimer) cancelEventTimer(evtType TimerEventType, blockNum uint32) {
timers := self.eventTimers[evtType]

if t, present := timers[blockNum]; present {
t.Stop()
delete(timers, blockNum)
}

return nil
}

func (self *EventTimer) StartProposalTimer(blockNum uint32) error {
func (self *EventTimer) StartProposalTimer(blockNum uint32) {
self.lock.Lock()
defer self.lock.Unlock()

log.Infof("server %d started proposal timer for blk %d", self.server.Index, blockNum)
return self.startEventTimer(EventProposeBlockTimeout, blockNum)
self.startEventTimer(EventProposeBlockTimeout, blockNum)
}

func (self *EventTimer) CancelProposalTimer(blockNum uint32) error {
func (self *EventTimer) CancelProposalTimer(blockNum uint32) {
self.lock.Lock()
defer self.lock.Unlock()

return self.cancelEventTimer(EventProposeBlockTimeout, blockNum)
self.cancelEventTimer(EventProposeBlockTimeout, blockNum)
}

func (self *EventTimer) StartEndorsingTimer(blockNum uint32) error {
func (self *EventTimer) StartEndorsingTimer(blockNum uint32) {
self.lock.Lock()
defer self.lock.Unlock()

log.Infof("server %d started endorsing timer for blk %d", self.server.Index, blockNum)
return self.startEventTimer(EventEndorseBlockTimeout, blockNum)
self.startEventTimer(EventEndorseBlockTimeout, blockNum)
}

func (self *EventTimer) CancelEndorseMsgTimer(blockNum uint32) error {
func (self *EventTimer) CancelEndorseMsgTimer(blockNum uint32) {
self.lock.Lock()
defer self.lock.Unlock()

return self.cancelEventTimer(EventEndorseBlockTimeout, blockNum)
self.cancelEventTimer(EventEndorseBlockTimeout, blockNum)
}

func (self *EventTimer) StartEndorseEmptyBlockTimer(blockNum uint32) error {
func (self *EventTimer) StartEndorseEmptyBlockTimer(blockNum uint32) {
self.lock.Lock()
defer self.lock.Unlock()

log.Infof("server %d started empty endorsing timer for blk %d", self.server.Index, blockNum)
return self.startEventTimer(EventEndorseEmptyBlockTimeout, blockNum)
self.startEventTimer(EventEndorseEmptyBlockTimeout, blockNum)
}

func (self *EventTimer) CancelEndorseEmptyBlockTimer(blockNum uint32) error {
func (self *EventTimer) CancelEndorseEmptyBlockTimer(blockNum uint32) {
self.lock.Lock()
defer self.lock.Unlock()

return self.cancelEventTimer(EventEndorseEmptyBlockTimeout, blockNum)
self.cancelEventTimer(EventEndorseEmptyBlockTimeout, blockNum)
}

func (self *EventTimer) StartCommitTimer(blockNum uint32) error {
func (self *EventTimer) StartCommitTimer(blockNum uint32) {
self.lock.Lock()
defer self.lock.Unlock()

log.Infof("server %d started commit timer for blk %d", self.server.Index, blockNum)
return self.startEventTimer(EventCommitBlockTimeout, blockNum)
self.startEventTimer(EventCommitBlockTimeout, blockNum)
}

func (self *EventTimer) CancelCommitMsgTimer(blockNum uint32) error {
func (self *EventTimer) CancelCommitMsgTimer(blockNum uint32) {
self.lock.Lock()
defer self.lock.Unlock()

return self.cancelEventTimer(EventCommitBlockTimeout, blockNum)
self.cancelEventTimer(EventCommitBlockTimeout, blockNum)
}

func (self *EventTimer) StartProposalBackoffTimer(blockNum uint32) error {
func (self *EventTimer) StartProposalBackoffTimer(blockNum uint32) {
self.lock.Lock()
defer self.lock.Unlock()

return self.startEventTimer(EventProposalBackoff, blockNum)
self.startEventTimer(EventProposalBackoff, blockNum)
}

func (self *EventTimer) CancelProposalBackoffTimer(blockNum uint32) error {
func (self *EventTimer) CancelProposalBackoffTimer(blockNum uint32) {
self.lock.Lock()
defer self.lock.Unlock()

return self.cancelEventTimer(EventProposalBackoff, blockNum)
self.cancelEventTimer(EventProposalBackoff, blockNum)
}

func (self *EventTimer) StartBackoffTimer(blockNum uint32) error {
func (self *EventTimer) StartBackoffTimer(blockNum uint32) {
self.lock.Lock()
defer self.lock.Unlock()

return self.startEventTimer(EventRandomBackoff, blockNum)
self.startEventTimer(EventRandomBackoff, blockNum)
}

func (self *EventTimer) CancelBackoffTimer(blockNum uint32) error {
func (self *EventTimer) CancelBackoffTimer(blockNum uint32) {
self.lock.Lock()
defer self.lock.Unlock()

return self.cancelEventTimer(EventRandomBackoff, blockNum)
self.cancelEventTimer(EventRandomBackoff, blockNum)
}

func (self *EventTimer) Start2ndProposalTimer(blockNum uint32) error {
func (self *EventTimer) Start2ndProposalTimer(blockNum uint32) {
self.lock.Lock()
defer self.lock.Unlock()

return self.startEventTimer(EventPropose2ndBlockTimeout, blockNum)
self.startEventTimer(EventPropose2ndBlockTimeout, blockNum)
}

func (self *EventTimer) Cancel2ndProposalTimer(blockNum uint32) error {
func (self *EventTimer) Cancel2ndProposalTimer(blockNum uint32) {
self.lock.Lock()
defer self.lock.Unlock()

return self.cancelEventTimer(EventPropose2ndBlockTimeout, blockNum)
self.cancelEventTimer(EventPropose2ndBlockTimeout, blockNum)
}

func (self *EventTimer) onBlockSealed(blockNum uint32) {
Expand All @@ -334,25 +327,22 @@ func (self *EventTimer) onBlockSealed(blockNum uint32) {

// clear event timers
for i := 0; i < int(EventMax); i++ {
if err := self.cancelEventTimer(TimerEventType(i), blockNum); err != nil {
log.Errorf("server %d, failed to stop timer %d on sealing",
self.server.Index, i)
}
self.cancelEventTimer(TimerEventType(i), blockNum)
}
}

func (self *EventTimer) StartTxBlockTimeout(blockNum uint32) error {
func (self *EventTimer) StartTxBlockTimeout(blockNum uint32) {
self.lock.Lock()
defer self.lock.Unlock()

return self.startEventTimer(EventTxBlockTimeout, blockNum)
self.startEventTimer(EventTxBlockTimeout, blockNum)
}

func (self *EventTimer) CancelTxBlockTimeout(blockNum uint32) error {
func (self *EventTimer) CancelTxBlockTimeout(blockNum uint32) {
self.lock.Lock()
defer self.lock.Unlock()

return self.cancelEventTimer(EventTxBlockTimeout, blockNum)
self.cancelEventTimer(EventTxBlockTimeout, blockNum)
}

func (self *EventTimer) startPeerTicker(peerIdx uint32) error {
Expand Down Expand Up @@ -387,18 +377,18 @@ func (self *EventTimer) stopPeerTicker(peerIdx uint32) error {
return nil
}

func (self *EventTimer) startTxTicker(blockNum uint32) error {
func (self *EventTimer) startTxTicker(blockNum uint32) {
self.lock.Lock()
defer self.lock.Unlock()

return self.startEventTimer(EventTxPool, blockNum)
self.startEventTimer(EventTxPool, blockNum)
}

func (self *EventTimer) stopTxTicker(blockNum uint32) error {
func (self *EventTimer) stopTxTicker(blockNum uint32) {
self.lock.Lock()
defer self.lock.Unlock()

return self.cancelEventTimer(EventTxPool, blockNum)
self.cancelEventTimer(EventTxPool, blockNum)
}

///////////////////////////////////////////////////////////
Expand Down
18 changes: 6 additions & 12 deletions consensus/vbft/event_timer_test.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -27,28 +27,22 @@ func constructEventTimer() *EventTimer {

func TestStartTimer(t *testing.T) {
eventtimer := constructEventTimer()
err := eventtimer.StartTimer(1, 10)
t.Logf("TestStartTimer: %v", err)
eventtimer.StartTimer(1, 10)
}

func TestCancelTimer(t *testing.T) {
eventtimer := constructEventTimer()
err := eventtimer.StartTimer(1, 10)
t.Logf("TestStartTimer: %v", err)
err = eventtimer.CancelTimer(1)
t.Logf("TestCancelTimer: %v", err)
eventtimer.StartTimer(1, 10)
eventtimer.CancelTimer(1)
}

func TestStartEventTimer(t *testing.T) {
eventtimer := constructEventTimer()
err := eventtimer.startEventTimer(EventProposeBlockTimeout, 1)
t.Logf("TestStartEventTimer: %v", err)
eventtimer.startEventTimer(EventProposeBlockTimeout, 1)
}

func TestCancelEventTimer(t *testing.T) {
eventtimer := constructEventTimer()
err := eventtimer.startEventTimer(EventProposeBlockTimeout, 1)
t.Logf("startEventTimer: %v", err)
err = eventtimer.cancelEventTimer(EventProposeBlockTimeout, 1)
t.Logf("cancelEventTimer: %v", err)
eventtimer.startEventTimer(EventProposeBlockTimeout, 1)
eventtimer.cancelEventTimer(EventProposeBlockTimeout, 1)
}

0 comments on commit cb50c3b

Please sign in to comment.