Ask a question about incrementProposerPriority func

[james-ray]

func (vals *ValidatorSet) incrementProposerPriority(subAvg bool) *Validator {
	for _, val := range vals.Validators {
		// Check for overflow for sum.
		val.ProposerPriority = safeAddClip(val.ProposerPriority, val.VotingPower)
	}

	validatorsHeap := cmn.NewHeap()
	if subAvg { // shift by avg ProposerPriority
		vals.shiftByAvgProposerPriority(validatorsHeap)
	} else { // just update the heap
		for _, val := range vals.Validators {
			validatorsHeap.PushComparable(val, proposerPriorityComparable{val})
		}
	}

	// Decrement the validator with most ProposerPriority:
	mostest := validatorsHeap.Peek().(*Validator)
	// mind underflow
	mostest.ProposerPriority = safeSubClip(mostest.ProposerPriority, vals.TotalVotingPower())

	return mostest
}

Before, we just let the mostest sub totalVotingPower. Now, we do one more step shiftByAvgProposerPriority. In this func, each validator sub avgPower. So I think the whole validatorSet sub twice totalPower.

Does that make sense? It will become negative and smaller and smaller.
Am I misunderstanding something? Please, anybody, tell me? Thanks!

[james-ray]

I have looked into #2718 and #2785 . not fully understood.. still trying to get the answer.

Seems like the totalPower can be substracted to negative, so the avg can be negative too, so sub the avgPower will not lead to become smaller and smaller but close to 0.

[james-ray]

In this func IncrementProposerPriority:

``
func (vals *ValidatorSet) IncrementProposerPriority(times int) {
if times <= 0 {
panic("Cannot call IncrementProposerPriority with non-positive times")
}

const shiftEveryNthIter = 10
var proposer *Validator
// call IncrementProposerPriority(1) times times:
for i := 0; i < times; i++ {
	shiftByAvgProposerPriority := i%shiftEveryNthIter == 0
	proposer = vals.incrementProposerPriority(shiftByAvgProposerPriority)
}
isShiftedAvgOnLastIter := (times-1)%shiftEveryNthIter == 0
if !isShiftedAvgOnLastIter {
	validatorsHeap := cmn.NewHeap()
	vals.shiftByAvgProposerPriority(validatorsHeap)
}
vals.Proposer = proposer

}
``
we have a local const shiftEveryNthIter=10, How about the consensus goes well and we finish each height at round 0, so the times here is always 1, so the shiftByAvgProposerPriority will not get executed because isShiftedAvgOnLastIter := (times-1)%shiftEveryNthIter == 0 is true.

I sugguest we can add a variable incrCount in validatorSet, we increase the count each time, and execute shiftByAvgProposerPriority when it reaches 10, then reset it to 0 again.

[melekes]

Proposer selection algorithm has undergone a few changes in the past releases. @james-ray do you still have questions? Have you looked at the new implementation and formal specification?

[ebuchman]

@james-ray can we close this?

[james-ray]

Yes, I see the code there is completely different now.