feat: implement random sampling without replacement and staking power

CHANGELOG_PENDING.md

@@ -12,7 +12,12 @@
 
 - Go API
 
+  - [types] [\#83](https://github.com/line/tendermint/pull/83) Add `StakingPower` to `Validator`
+  - [consensus] [\#83](https://github.com/line/tendermint/pull/83) Change calculation of `VotingPower`
+
 ### FEATURES:
+- [rpc] [\#78](https://github.com/line/tendermint/pull/78) Add `Voters` rpc
+- [consensus] [\#83](https://github.com/line/tendermint/pull/83) Selection voters using random sampling without replacement
 
 ### IMPROVEMENTS:
 

blockchain/v0/reactor_test.go

@@ -32,7 +32,7 @@ func randGenesisDoc(numValidators int, randPower bool, minPower int64) (*types.G
 		val, privVal := types.RandValidator(randPower, minPower)
 		validators[i] = types.GenesisValidator{
 			PubKey: val.PubKey,
-			Power:  val.VotingPower,
+			Power:  val.StakingPower,
 		}
 		privValidators[i] = privVal
 	}

blockchain/v1/reactor_test.go

@@ -35,7 +35,7 @@ func randGenesisDoc(numValidators int, randPower bool, minPower int64) (*types.G
 		val, privVal := types.RandValidator(randPower, minPower)
 		validators[i] = types.GenesisValidator{
 			PubKey: val.PubKey,
-			Power:  val.VotingPower,
+			Power:  val.StakingPower,
 		}
 		privValidators[i] = privVal
 	}

blockchain/v2/reactor_test.go

@@ -464,7 +464,7 @@ func randGenesisDoc(chainID string, numValidators int, randPower bool, minPower
 		val, privVal := types.RandValidator(randPower, minPower)
 		validators[i] = types.GenesisValidator{
 			PubKey: val.PubKey,
-			Power:  val.VotingPower,
+			Power:  val.StakingPower,
 		}
 		privValidators[i] = privVal
 	}

consensus/common_test.go

@@ -804,7 +804,7 @@ func randGenesisDoc(numValidators int, randPower bool, minPower int64) (*types.G
 		val, privVal := types.RandValidator(randPower, minPower)
 		validators[i] = types.GenesisValidator{
 			PubKey: val.PubKey,
-			Power:  val.VotingPower,
+			Power:  val.StakingPower,
 		}
 		privValidators[i] = privVal
 	}

consensus/reactor_test.go

@@ -335,7 +335,7 @@ func TestReactorRecordsVotesAndBlockParts(t *testing.T) {
 //-------------------------------------------------------------
 // ensure we can make blocks despite cycling a validator set
 
-func TestReactorVotingPowerChange(t *testing.T) {
+func TestReactorStakingPowerChange(t *testing.T) {
 	nVals := 4
 	logger := log.TestingLogger()
 	css, cleanup := randConsensusNet(
@@ -377,7 +377,7 @@ func TestReactorVotingPowerChange(t *testing.T) {
 
 	if css[0].GetRoundState().LastVoters.TotalVotingPower() == previousTotalVotingPower {
 		t.Fatalf(
-			"expected voting power to change (before: %d, after: %d)",
+			"expected staking power to change (before: %d, after: %d)",
 			previousTotalVotingPower,
 			css[0].GetRoundState().LastVoters.TotalVotingPower())
 	}
@@ -486,7 +486,7 @@ func TestReactorValidatorSetChanges(t *testing.T) {
 
 	if css[nVals].GetRoundState().LastVoters.TotalVotingPower() == previousTotalVotingPower {
 		t.Errorf(
-			"expected voting power to change (before: %d, after: %d)",
+			"expected staking power to change (before: %d, after: %d)",
 			previousTotalVotingPower,
 			css[nVals].GetRoundState().LastVoters.TotalVotingPower())
 	}

consensus/replay.go

@@ -329,7 +329,7 @@ func (h *Handshaker) ReplayBlocks(
 					return nil, err
 				}
 				state.Validators = types.NewValidatorSet(vals)
-				state.Voters = types.ToVoterAll(state.Validators)
+				state.Voters = types.ToVoterAll(state.Validators.Validators)
 				// Should sync it with MakeGenesisState()
 				state.NextValidators = types.NewValidatorSet(vals)
 				state.NextVoters = types.SelectVoter(state.NextValidators, h.genDoc.Hash())

consensus/state.go

@@ -205,7 +205,7 @@ func StateMetrics(metrics *Metrics) StateOption {
 // String returns a string.
 func (cs *State) String() string {
 	// better not to access shared variables
-	return "ConsensusState" //(H:%v R:%v S:%v", cs.Height, cs.Round, cs.Step)
+	return "ConsensusState" // (H:%v R:%v S:%v", cs.Height, cs.Round, cs.Step)
 }
 
 // GetState returns a copy of the chain state.
@@ -1557,7 +1557,6 @@ func (cs *State) recordMetrics(height int64, block *types.Block) {
 					cs.Logger.Error("Error on retrival of pubkey", "err", err)
 					continue
 				}
-
 				if bytes.Equal(val.Address, pubKey.Address()) {
 					label := []string{
 						"validator_address", val.Address.String(),

consensus/state_test.go

@@ -184,7 +184,7 @@ func TestStateBadProposal(t *testing.T) {
 	proposalCh := subscribe(cs1.eventBus, types.EventQueryCompleteProposal)
 	voteCh := subscribe(cs1.eventBus, types.EventQueryVote)
 
-	propBlock, _ := cs1.createProposalBlock(round) //changeProposer(t, cs1, vs2)
+	propBlock, _ := cs1.createProposalBlock(round) // changeProposer(t, cs1, vs2)
 
 	// make the second validator the proposer by incrementing round
 	round++

evidence/pool.go

@@ -113,7 +113,7 @@ func (evpool *Pool) AddEvidence(evidence types.Evidence) error {
 		return err
 	}
 	_, val := valSet.GetByAddress(evidence.Address())
-	priority := val.VotingPower
+	priority := val.StakingPower
 
 	_, err = evpool.store.AddNewEvidence(evidence, priority)
 	if err != nil {

evidence/pool_test.go

@@ -27,7 +27,7 @@ func initializeValidatorState(valAddr []byte, height int64) dbm.DB {
 
 	// create validator set and state
 	vals := []*types.Validator{
-		{Address: valAddr, VotingPower: 1},
+		{Address: valAddr, StakingPower: 1},
 	}
 	state := sm.State{
 		LastBlockHeight:             0,

libs/rand/sampling.go

@@ -2,18 +2,18 @@ package rand
 
 import (
 	"fmt"
+	"math"
+	"math/big"
 	s "sort"
 )
 
 // Interface for performing weighted deterministic random selection.
 type Candidate interface {
 	Priority() uint64
 	LessThan(other Candidate) bool
-	IncreaseWin()
+	SetWinPoint(winPoint int64)
 }
 
-const uint64Mask = uint64(0x7FFFFFFFFFFFFFFF)
-
 // Select a specified number of candidates randomly from the candidate set based on each priority. This function is
 // deterministic and will produce the same result for the same input.
 //
@@ -33,7 +33,7 @@ func RandomSamplingWithPriority(
 	thresholds := make([]uint64, sampleSize)
 	for i := 0; i < sampleSize; i++ {
 		// calculating [gross weights] × [(0,1] random number]
-		thresholds[i] = uint64(float64(nextRandom(&seed)&uint64Mask) / float64(uint64Mask+1) * float64(totalPriority))
+		thresholds[i] = randomThreshold(&seed, totalPriority)
 	}
 	s.Slice(thresholds, func(i, j int) bool { return thresholds[i] < thresholds[j] })
 
@@ -66,52 +66,115 @@ func RandomSamplingWithPriority(
 		totalPriority, actualTotalPriority, seed, sampleSize, undrawn, undrawn, thresholds[undrawn], len(candidates)))
 }
 
-const MaxSamplingLoopTry = 1000
+func moveWinnerToLast(candidates []Candidate, winner int) {
+	winnerCandidate := candidates[winner]
+	copy(candidates[winner:], candidates[winner+1:])
+	candidates[len(candidates)-1] = winnerCandidate
+}
+
+const uint64Mask = uint64(0x7FFFFFFFFFFFFFFF)
+
+var divider *big.Int
+
+func init() {
+	divider = big.NewInt(int64(uint64Mask))
+	divider.Add(divider, big.NewInt(1))
+}
+
+func randomThreshold(seed *uint64, total uint64) uint64 {
+	if int64(total) < 0 {
+		panic(fmt.Sprintf("total priority is overflow: %d", total))
+	}
+	totalBig := big.NewInt(int64(total))
+	a := big.NewInt(int64(nextRandom(seed) & uint64Mask))
+	a.Mul(a, totalBig)
+	a.Div(a, divider)
+	return a.Uint64()
+}
 
-// `RandomSamplingToMax` elects voters among candidates so it updates wins of candidates
-// Voters can be elected by a maximum `limitCandidates`.
-// However, if the likely candidates are less than the `limitCandidates`,
-// the number of voters may be less than the `limitCandidates`.
-// This is to prevent falling into an infinite loop.
-func RandomSamplingToMax(
-	seed uint64, candidates []Candidate, limitCandidates int, totalPriority uint64) uint64 {
+// `RandomSamplingWithoutReplacement` elects winners among candidates without replacement
+// so it updates rewards of winners. This function continues to elect winners until the both of two
+// conditions(minSamplingCount, minPriorityPercent) are met.
+func RandomSamplingWithoutReplacement(
+	seed uint64, candidates []Candidate, minSamplingCount int, winPointUnit uint64) (
+	winners []Candidate) {
 
-	if len(candidates) < limitCandidates {
-		panic("The number of candidates cannot be less limitCandidate")
+	if len(candidates) < minSamplingCount {
+		panic(fmt.Sprintf("The number of candidates(%d) cannot be less minSamplingCount %d",
+			len(candidates), minSamplingCount))
 	}
 
+	totalPriority := sumTotalPriority(candidates)
 	candidates = sort(candidates)
-	totalSampling := uint64(0)
-	winCandidates := make(map[Candidate]bool)
-	for len(winCandidates) < limitCandidates && totalSampling < MaxSamplingLoopTry {
-		threshold := uint64(float64(nextRandom(&seed)&uint64Mask) / float64(uint64Mask+1) * float64(totalPriority))
+	winnersPriority := uint64(0)
+	losersPriorities := make([]uint64, len(candidates))
+	winnerNum := 0
+	for winnerNum < minSamplingCount {
+		if totalPriority-winnersPriority == 0 {
+			// it's possible if some candidates have zero priority
+			// if then, we can't elect voter any more; we should holt electing not to fall in infinity loop
+			break
+		}
+		threshold := randomThreshold(&seed, totalPriority-winnersPriority)
 		cumulativePriority := uint64(0)
 		found := false
-		for _, candidate := range candidates {
+		for i, candidate := range candidates[:len(candidates)-winnerNum] {
 			if threshold < cumulativePriority+candidate.Priority() {
-				if !winCandidates[candidate] {
-					winCandidates[candidate] = true
-				}
-				candidate.IncreaseWin()
-				totalSampling++
+				moveWinnerToLast(candidates, i)
+				winnersPriority += candidate.Priority()
+				losersPriorities[winnerNum] = totalPriority - winnersPriority
+				winnerNum++
 				found = true
 				break
 			}
 			cumulativePriority += candidate.Priority()
 		}
 
 		if !found {
-			panic(fmt.Sprintf("Cannot find random sample. totalPriority may be wrong: totalPriority=%d, "+
-				"actualTotalPriority=%d, threshold=%d", totalPriority, sumTotalPriority(candidates), threshold))
+			panic(fmt.Sprintf("Cannot find random sample. winnerNum=%d, minSamplingCount=%d, "+
+				"winnersPriority=%d, totalPriority=%d, threshold=%d",
+				winnerNum, minSamplingCount, winnersPriority, totalPriority, threshold))
+		}
+	}
+	compensationProportions := make([]float64, winnerNum)
+	for i := winnerNum - 2; i >= 0; i-- { // last winner doesn't get compensation reward
+		compensationProportions[i] = compensationProportions[i+1] + 1/float64(losersPriorities[i])
+	}
+	winners = candidates[len(candidates)-winnerNum:]
+	winPoints := make([]float64, len(winners))
+	downscaleNeeded := false
+	for i, winner := range winners {
+		winPoints[i] = float64(winPointUnit) +
+			float64(winner.Priority())*compensationProportions[i]*float64(winPointUnit)
+		if int64(winPoints[i]) < 0 {
+			downscaleNeeded = true
+		}
+	}
+	for downscaleNeeded {
+		downscaleNeeded = false
+		for i := range winPoints {
+			winPoints[i] /= 10
+			if int64(winPoints[i]) < 0 {
+				downscaleNeeded = true
+			}
 		}
 	}
-	return totalSampling
+	for i, winner := range winners {
+		if winPoints[i] > math.MaxInt64 || winPoints[i] < 0 {
+			panic(fmt.Sprintf("winPoint is invalid: %f", winPoints[i]))
+		}
+		winner.SetWinPoint(int64(winPoints[i]))
+	}
+	return winners
 }
 
 func sumTotalPriority(candidates []Candidate) (sum uint64) {
 	for _, candi := range candidates {
 		sum += candi.Priority()
 	}
+	if sum == 0 {
+		panic("all candidates have zero priority")
+	}
 	return
 }