Implement storage power evolution in simulations for honest participants

sim/cmd/f3sim/f3sim.go

@@ -39,7 +39,10 @@ func main() {
 			sim.WithLatencyModel(latencyModel),
 			sim.WithECEpochDuration(30 * time.Second),
 			sim.WithECStabilisationDelay(0),
-			sim.AddHonestParticipants(*participantCount, sim.NewUniformECChainGenerator(uint64(seed), 1, 10)),
+			sim.AddHonestParticipants(
+				*participantCount,
+				sim.NewUniformECChainGenerator(uint64(seed), 1, 10),
+				sim.UniformStoragePower(gpbft.NewStoragePower(1))),
 			sim.WithTraceLevel(*traceLevel),
 			sim.WithGpbftOptions(
 				gpbft.WithDelta(*delta),

sim/ecchain_gen.go

@@ -147,3 +147,14 @@ func (u *AggregateECChainGenerator) GenerateECChain(instance uint64, base gpbft.
 	}
 	return chain
 }
+
+var _ ECChainGenerator = (*BaseECChainGenerator)(nil)
+
+// BaseECChainGenerator always return the given base as the EC chain for all participants and instances.
+type BaseECChainGenerator struct{}
+
+func NewBaseECChainGenerator() *BaseECChainGenerator { return &BaseECChainGenerator{} }
+
+func (u *BaseECChainGenerator) GenerateECChain(_ uint64, base gpbft.TipSet, _ gpbft.ActorID) gpbft.ECChain {
+	return gpbft.ECChain{base}
+}

sim/host.go

@@ -18,24 +18,29 @@ type simHost struct {
 	gpbft.Verifier
 	gpbft.Clock
 
-	id  gpbft.ActorID
-	sim *Simulation
+	id     gpbft.ActorID
+	sim    *Simulation
+	pubkey gpbft.PubKey
 
 	// The simulation package always starts at instance zero.
 	// TODO: https://github.com/filecoin-project/go-f3/issues/195
 	instance uint64
 	ecChain  gpbft.ECChain
 	ecg      ECChainGenerator
+	spg      StoragePowerGenerator
 }
 
-func newHost(id gpbft.ActorID, sim *Simulation, ecg ECChainGenerator) *simHost {
+func newHost(id gpbft.ActorID, sim *Simulation, ecg ECChainGenerator, spg StoragePowerGenerator) *simHost {
+	pubKey, _ := sim.signingBacked.GenerateKey()
 	return &simHost{
 		Network:  sim.network,
 		Verifier: sim.signingBacked,
 		Signer:   sim.signingBacked,
 		sim:      sim,
 		id:       id,
 		ecg:      ecg,
+		spg:      spg,
+		pubkey:   pubKey,
 		ecChain:  *sim.baseChain,
 	}
 }
@@ -65,3 +70,15 @@ func (v *simHost) ReceiveDecision(decision *gpbft.Justification) time.Time {
 func (v *simHost) BroadcastSynchronous(sender gpbft.ActorID, msg gpbft.GMessage) {
 	v.sim.network.BroadcastSynchronous(sender, msg)
 }
+
+func (v *simHost) StoragePower() *gpbft.StoragePower {
+	return v.spg(v.instance, v.id)
+}
+
+func (v *simHost) PublicKey() gpbft.PubKey {
+	return v.pubkey
+}
+
+func (v *simHost) ID() gpbft.ActorID {
+	return v.id
+}

sim/options.go

@@ -53,8 +53,9 @@ type options struct {
 }
 
 type participantArchetype struct {
-	count            int
-	ecChainGenerator ECChainGenerator
+	count                 int
+	ecChainGenerator      ECChainGenerator
+	storagePowerGenerator StoragePowerGenerator
 }
 
 func newOptions(o ...Option) (*options, error) {
@@ -143,15 +144,16 @@ func WithBaseChain(base *gpbft.ECChain) Option {
 	}
 }
 
-func AddHonestParticipants(count int, generator ECChainGenerator) Option {
+func AddHonestParticipants(count int, ecg ECChainGenerator, spg StoragePowerGenerator) Option {
 	return func(o *options) error {
 		if count <= 0 {
 			return fmt.Errorf("honest participant count must be larger than zero; got: %d", count)
 		}
 		o.honestParticipantArchetypes = append(o.honestParticipantArchetypes,
 			participantArchetype{
-				count:            count,
-				ecChainGenerator: generator,
+				count:                 count,
+				ecChainGenerator:      ecg,
+				storagePowerGenerator: spg,
 			})
 		return nil
 	}

sim/sim.go

@@ -12,6 +12,7 @@ type Simulation struct {
 	*options
 	network      *Network
 	ec           *simEC
+	hosts        []*simHost
 	participants []*gpbft.Participant
 	adversary    *adversary.Adversary
 }
@@ -33,11 +34,10 @@ func (s *Simulation) Run(instanceCount uint64, maxRounds uint64) error {
 	if err := s.initParticipants(); err != nil {
 		return err
 	}
-	pt, err := s.initPowerTable()
+	pt, err := s.getPowerTable()
 	if err != nil {
 		return err
 	}
-
 	currentInstance := s.ec.BeginInstance(*s.baseChain, pt, s.beacon)
 	s.startParticipants()
 
@@ -65,13 +65,14 @@ func (s *Simulation) Run(instanceCount uint64, maxRounds uint64) error {
 				return fmt.Errorf("concensus was not reached at instance %d", currentInstance.Instance)
 			}
 
+			pt, err := s.getPowerTable()
+			if err != nil {
+				return err
+			}
+
 			// Instantiate the next instance even if it goes beyond finalInstance.
 			// The last incomplete instance is used for testing assertions.
-			currentInstance = s.ec.BeginInstance(*decidedChain,
-				// Copy the previous instance power table.
-				// The simulator doesn't have any facility to evolve the power table.
-				// See https://github.com/filecoin-project/go-f3/issues/114.
-				currentInstance.PowerTable.Copy(),
+			currentInstance = s.ec.BeginInstance(*decidedChain, pt,
 				[]byte(fmt.Sprintf("beacon %d", currentInstance.Instance+1)),
 			)
 
@@ -105,34 +106,20 @@ func (s *Simulation) startParticipants() {
 	}
 }
 
-func (s *Simulation) initPowerTable() (*gpbft.PowerTable, error) {
+func (s *Simulation) getPowerTable() (*gpbft.PowerTable, error) {
 	pEntries := make([]gpbft.PowerEntry, 0, len(s.participants))
 	// Set chains for first instance
-	for _, p := range s.participants {
-		pubKey, _ := s.signingBacked.GenerateKey()
+	for _, h := range s.hosts {
 		pEntries = append(pEntries, gpbft.PowerEntry{
-			ID: p.ID(),
-			// TODO: support varying power distribution across participants.
-			//       See: https://github.com/filecoin-project/go-f3/issues/114.
-			Power:  gpbft.NewStoragePower(1),
-			PubKey: pubKey,
+			ID:     h.ID(),
+			Power:  h.StoragePower(),
+			PubKey: h.PublicKey(),
 		})
 	}
 	pt := gpbft.NewPowerTable()
 	if err := pt.Add(pEntries...); err != nil {
 		return nil, fmt.Errorf("failed to set up power table at first instance: %w", err)
 	}
-	if s.adversary != nil {
-		aPubKey, _ := s.signingBacked.GenerateKey()
-		err := pt.Add(gpbft.PowerEntry{
-			ID:     s.adversary.ID(),
-			Power:  s.adversary.Power,
-			PubKey: aPubKey,
-		})
-		if err != nil {
-			return nil, fmt.Errorf("failed to set up adversary power entry at first instance: %w", err)
-		}
-	}
 	return pt, nil
 }
 
@@ -141,28 +128,28 @@ func (s *Simulation) initParticipants() error {
 	var nextID gpbft.ActorID
 	for _, archetype := range s.honestParticipantArchetypes {
 		for i := 0; i < archetype.count; i++ {
-			host := newHost(nextID, s, archetype.ecChainGenerator)
+			host := newHost(nextID, s, archetype.ecChainGenerator, archetype.storagePowerGenerator)
 			participant, err := gpbft.NewParticipant(nextID, host, pOpts...)
 			if err != nil {
 				return fmt.Errorf("failed to instnatiate participant: %w", err)
 			}
 			s.participants = append(s.participants, participant)
+			s.hosts = append(s.hosts, host)
 			s.network.AddParticipant(participant)
 			nextID++
 		}
 	}
 
-	// TODO: expand the simulation to accommodate more than one adversary for
-	//       a more realistic simulation.
-	// Limit adversaryCount to exactly one for now to reduce LOC up for review.
-	// Future PRs will expand this to support a group of adversaries.
+	// There is at most one adversary but with arbitrary power.
 	if s.adversaryGenerator != nil && s.adversaryCount == 1 {
+		host := newHost(nextID, s, NewFixedECChainGenerator(*s.baseChain), nil)
 		// Adversary implementations currently ignore the canonical chain.
 		// Set to a fixed ec chain generator and expand later for possibility
 		// of implementing adversaries that adapt based on ec chain.
-		// TODO: expand adversary archetypes.
-		host := newHost(nextID, s, NewFixedECChainGenerator(*s.baseChain))
 		s.adversary = s.adversaryGenerator(nextID, host)
+		// Adversary power does not evolve.
+		host.spg = UniformStoragePower(s.adversary.Power)
+		s.hosts = append(s.hosts, host)
 		s.network.AddParticipant(s.adversary)
 	}
 	return nil

sim/storage_power_gen.go

@@ -0,0 +1,11 @@
+package sim
+
+import "github.com/filecoin-project/go-f3/gpbft"
+
+type StoragePowerGenerator func(instance uint64, id gpbft.ActorID) *gpbft.StoragePower
+
+func UniformStoragePower(power *gpbft.StoragePower) StoragePowerGenerator {
+	return func(uint64, gpbft.ActorID) *gpbft.StoragePower {
+		return power
+	}
+}

test/absent_test.go

@@ -14,7 +14,10 @@ func TestAbsent(t *testing.T) {
 	repeatInParallel(t, 1, func(t *testing.T, repetition int) {
 		// Total network size of 3 + 1, where the adversary has 1/4 of power.
 		sm, err := sim.NewSimulation(asyncOptions(t, repetition,
-			sim.AddHonestParticipants(3, sim.NewUniformECChainGenerator(tipSetGeneratorSeed, 1, 10)),
+			sim.AddHonestParticipants(
+				3,
+				sim.NewUniformECChainGenerator(tipSetGeneratorSeed, 1, 10),
+				uniformOneStoragePower),
 			sim.WithAdversary(adversary.NewAbsentGenerator(oneStoragePower)),
 		)...)
 		require.NoError(t, err)

test/constants_test.go

@@ -22,7 +22,8 @@ const (
 )
 
 var (
-	oneStoragePower = gpbft.NewStoragePower(1)
+	oneStoragePower        = gpbft.NewStoragePower(1)
+	uniformOneStoragePower = sim.UniformStoragePower(oneStoragePower)
 
 	// testGpbftOptions is configuration constants used across most tests.
 	// These values are not intended to reflect real-world conditions.

test/decide_test.go

@@ -15,7 +15,10 @@ func TestImmediateDecide(t *testing.T) {
 	baseChain := generateECChain(t, tsg)
 	adversaryValue := baseChain.Extend(tsg.Sample())
 	sm, err := sim.NewSimulation(asyncOptions(t, 1413,
-		sim.AddHonestParticipants(1, sim.NewUniformECChainGenerator(tipSetGeneratorSeed, 1, 10)),
+		sim.AddHonestParticipants(
+			1,
+			sim.NewUniformECChainGenerator(tipSetGeneratorSeed, 1, 10),
+			uniformOneStoragePower),
 		sim.WithBaseChain(&baseChain),
 		// Add the adversary to the simulation with 3/4 of total power.
 		sim.WithAdversary(adversary.NewImmediateDecideGenerator(adversaryValue, gpbft.NewStoragePower(3))),

test/honest_test.go

@@ -55,7 +55,7 @@ func TestHonest_ChainAgreement(t *testing.T) {
 			targetChain := baseChain.Extend(tsg.Sample())
 			test.options = append(test.options,
 				sim.WithBaseChain(&baseChain),
-				sim.AddHonestParticipants(test.participantCount, sim.NewFixedECChainGenerator(targetChain)))
+				sim.AddHonestParticipants(test.participantCount, sim.NewFixedECChainGenerator(targetChain), uniformOneStoragePower))
 			sm, err := sim.NewSimulation(test.options...)
 			require.NoError(t, err)
 
@@ -97,8 +97,8 @@ func TestHonest_ChainDisagreement(t *testing.T) {
 			anotherChain := baseChain.Extend(tsg.Sample())
 			test.options = append(test.options,
 				sim.WithBaseChain(&baseChain),
-				sim.AddHonestParticipants(1, sim.NewFixedECChainGenerator(oneChain)),
-				sim.AddHonestParticipants(1, sim.NewFixedECChainGenerator(anotherChain)),
+				sim.AddHonestParticipants(1, sim.NewFixedECChainGenerator(oneChain), uniformOneStoragePower),
+				sim.AddHonestParticipants(1, sim.NewFixedECChainGenerator(anotherChain), uniformOneStoragePower),
 			)
 			sm, err := sim.NewSimulation(test.options...)
 			require.NoError(t, err)
@@ -116,7 +116,7 @@ func TestSync_AgreementWithRepetition(t *testing.T) {
 		someChain := baseChain.Extend(tsg.Sample())
 		sm, err := sim.NewSimulation(syncOptions(
 			sim.WithBaseChain(&baseChain),
-			sim.AddHonestParticipants(honestCount, sim.NewFixedECChainGenerator(someChain)),
+			sim.AddHonestParticipants(honestCount, sim.NewFixedECChainGenerator(someChain), uniformOneStoragePower),
 		)...)
 		require.NoError(t, err)
 
@@ -142,7 +142,10 @@ func TestAsyncAgreement(t *testing.T) {
 				someChain := baseChain.Extend(tsg.Sample())
 				sm, err := sim.NewSimulation(asyncOptions(t, repetition,
 					sim.WithBaseChain(&baseChain),
-					sim.AddHonestParticipants(honestCount, sim.NewFixedECChainGenerator(someChain)),
+					sim.AddHonestParticipants(
+						honestCount,
+						sim.NewFixedECChainGenerator(someChain),
+						uniformOneStoragePower),
 				)...)
 				require.NoError(t, err)
 				require.NoErrorf(t, sm.Run(1, maxRounds), "%s", sm.Describe())
@@ -163,8 +166,8 @@ func TestSyncHalves(t *testing.T) {
 		anotherChain := baseChain.Extend(tsg.Sample())
 		sm, err := sim.NewSimulation(syncOptions(
 			sim.WithBaseChain(&baseChain),
-			sim.AddHonestParticipants(honestCount/2, sim.NewFixedECChainGenerator(oneChain)),
-			sim.AddHonestParticipants(honestCount/2, sim.NewFixedECChainGenerator(anotherChain)),
+			sim.AddHonestParticipants(honestCount/2, sim.NewFixedECChainGenerator(oneChain), uniformOneStoragePower),
+			sim.AddHonestParticipants(honestCount/2, sim.NewFixedECChainGenerator(anotherChain), uniformOneStoragePower),
 		)...)
 		require.NoError(t, err)
 		require.NoErrorf(t, sm.Run(1, maxRounds), "%s", sm.Describe())
@@ -188,8 +191,8 @@ func TestSyncHalvesBLS(t *testing.T) {
 		sm, err := sim.NewSimulation(syncOptions(
 			sim.WithSigningBackend(signing.NewBLSBackend()),
 			sim.WithBaseChain(&baseChain),
-			sim.AddHonestParticipants(honestCount/2, sim.NewFixedECChainGenerator(oneChain)),
-			sim.AddHonestParticipants(honestCount/2, sim.NewFixedECChainGenerator(anotherChain)),
+			sim.AddHonestParticipants(honestCount/2, sim.NewFixedECChainGenerator(oneChain), uniformOneStoragePower),
+			sim.AddHonestParticipants(honestCount/2, sim.NewFixedECChainGenerator(anotherChain), uniformOneStoragePower),
 		)...)
 		require.NoError(t, err)
 		require.NoErrorf(t, sm.Run(1, maxRounds), "%s", sm.Describe())
@@ -214,8 +217,8 @@ func TestAsyncHalves(t *testing.T) {
 				anotherChain := baseChain.Extend(tsg.Sample())
 				sm, err := sim.NewSimulation(asyncOptions(t, repetition,
 					sim.WithBaseChain(&baseChain),
-					sim.AddHonestParticipants(honestCount/2, sim.NewFixedECChainGenerator(oneChain)),
-					sim.AddHonestParticipants(honestCount/2, sim.NewFixedECChainGenerator(anotherChain)),
+					sim.AddHonestParticipants(honestCount/2, sim.NewFixedECChainGenerator(oneChain), uniformOneStoragePower),
+					sim.AddHonestParticipants(honestCount/2, sim.NewFixedECChainGenerator(anotherChain), uniformOneStoragePower),
 				)...)
 				require.NoError(t, err)
 				require.NoErrorf(t, sm.Run(1, maxRounds), "%s", sm.Describe())
@@ -239,8 +242,8 @@ func TestRequireStrongQuorumToProgress(t *testing.T) {
 		anotherChain := baseChain.Extend(tsg.Sample())
 		sm, err := sim.NewSimulation(asyncOptions(t, repetition,
 			sim.WithBaseChain(&baseChain),
-			sim.AddHonestParticipants(10, sim.NewFixedECChainGenerator(oneChain)),
-			sim.AddHonestParticipants(20, sim.NewFixedECChainGenerator(anotherChain)),
+			sim.AddHonestParticipants(10, sim.NewFixedECChainGenerator(oneChain), uniformOneStoragePower),
+			sim.AddHonestParticipants(20, sim.NewFixedECChainGenerator(anotherChain), uniformOneStoragePower),
 		)...)
 		require.NoError(t, err)
 		require.NoErrorf(t, sm.Run(1, maxRounds), "%s", sm.Describe())
@@ -261,10 +264,10 @@ func TestHonest_FixedLongestCommonPrefix(t *testing.T) {
 	abf := commonPrefix.Extend(tsg.Sample())
 	sm, err := sim.NewSimulation(syncOptions(
 		sim.WithBaseChain(&baseChain),
-		sim.AddHonestParticipants(1, sim.NewFixedECChainGenerator(abc)),
-		sim.AddHonestParticipants(1, sim.NewFixedECChainGenerator(abd)),
-		sim.AddHonestParticipants(1, sim.NewFixedECChainGenerator(abe)),
-		sim.AddHonestParticipants(1, sim.NewFixedECChainGenerator(abf)),
+		sim.AddHonestParticipants(1, sim.NewFixedECChainGenerator(abc), uniformOneStoragePower),
+		sim.AddHonestParticipants(1, sim.NewFixedECChainGenerator(abd), uniformOneStoragePower),
+		sim.AddHonestParticipants(1, sim.NewFixedECChainGenerator(abe), uniformOneStoragePower),
+		sim.AddHonestParticipants(1, sim.NewFixedECChainGenerator(abf), uniformOneStoragePower),
 	)...)
 	require.NoError(t, err)
 	require.NoErrorf(t, sm.Run(1, maxRounds), "%s", sm.Describe())
@@ -282,15 +285,15 @@ func TestHonest_MajorityCommonPrefix(t *testing.T) {
 		sim.AddHonestParticipants(20, sim.NewAppendingECChainGenerator(
 			majorityCommonPrefixGenerator,
 			sim.NewRandomECChainGenerator(23002354, 1, 8),
-		)),
+		), uniformOneStoragePower),
 		sim.AddHonestParticipants(5, sim.NewAppendingECChainGenerator(
 			sim.NewUniformECChainGenerator(84154, 1, 20),
 			sim.NewRandomECChainGenerator(8965741, 5, 8),
-		)),
+		), uniformOneStoragePower),
 		sim.AddHonestParticipants(1, sim.NewAppendingECChainGenerator(
 			sim.NewUniformECChainGenerator(2158, 10, 20),
 			sim.NewRandomECChainGenerator(154787878, 2, 8),
-		)),
+		), uniformOneStoragePower),
 	)...)
 	require.NoError(t, err)
 	require.NoErrorf(t, sm.Run(instanceCount, maxRounds), "%s", sm.Describe())