core/consensus: add longer proposer duty timeout (#3739)

Increase first round timeout value for proposer duty to 1.5s across all timers

category: feature
ticket: #3430
feature_flag: proposal_timeout

Author: DiogoSantoss

app/featureset/featureset.go

@@ -57,6 +57,9 @@ const (
 	// Previously this was the default behaviour, however, tracking on-chain inclusions post-electra is costly.
 	// The extra load that Charon puts the beacon node is deemed so high that it can throttle the completion of other duties.
 	AttestationInclusion Feature = "attestation_inclusion"
+
+	// ProposalTimeout enables a longer first consensus round timeout of 1.5 seconds for proposal duty.
+	ProposalTimeout = "proposal_timeout"
 )
 
 var (
@@ -71,6 +74,7 @@ var (
 		Linear:               statusAlpha,
 		SSEReorgDuties:       statusAlpha,
 		AttestationInclusion: statusAlpha,
+		ProposalTimeout:      statusAlpha,
 		// Add all features and there status here.
 	}
 

core/consensus/utils/roundtimer.go

@@ -28,25 +28,21 @@ func GetTimerFunc() TimerFunc {
 		return func(duty core.Duty) RoundTimer {
 			// Linear timer only affects Proposer duty
 			if duty.Type == core.DutyProposer {
-				return NewLinearRoundTimer()
+				return NewLinearRoundTimerWithDuty(duty)
 			} else if featureset.Enabled(featureset.EagerDoubleLinear) {
-				return NewDoubleEagerLinearRoundTimer()
+				return NewDoubleEagerLinearRoundTimerWithDuty(duty)
 			}
 
-			return NewIncreasingRoundTimer()
+			return NewIncreasingRoundTimerWithDuty(duty)
 		}
 	}
 
 	if featureset.Enabled(featureset.EagerDoubleLinear) {
-		return func(core.Duty) RoundTimer {
-			return NewDoubleEagerLinearRoundTimer()
-		}
+		return NewDoubleEagerLinearRoundTimerWithDuty
 	}
 
 	// Default to increasing round timer.
-	return func(core.Duty) RoundTimer {
-		return NewIncreasingRoundTimer()
-	}
+	return NewIncreasingRoundTimerWithDuty
 }
 
 // TimerType is the type of round timer.
@@ -82,6 +78,12 @@ type RoundTimer interface {
 	Type() TimerType
 }
 
+// proposalTimeoutOptimization returns true if ProposalTimeout feature is enabled, the duty is proposer and
+// we are in the first round.
+func proposalTimeoutOptimization(duty core.Duty, round int64) bool {
+	return featureset.Enabled(featureset.ProposalTimeout) && duty.Type == core.DutyProposer && round == 1
+}
+
 // NewTimeoutRoundTimer returns a new increasing round timer type.
 func NewIncreasingRoundTimer() RoundTimer {
 	return NewIncreasingRoundTimerWithClock(clockwork.NewRealClock())
@@ -94,17 +96,40 @@ func NewIncreasingRoundTimerWithClock(clock clockwork.Clock) RoundTimer {
 	}
 }
 
+// NewIncreasingRoundTimerWithDuty returns a new eager double linear round timer type for a specific duty.
+func NewIncreasingRoundTimerWithDuty(duty core.Duty) RoundTimer {
+	return &increasingRoundTimer{
+		clock: clockwork.NewRealClock(),
+		duty:  duty,
+	}
+}
+
+// NewIncreasingRoundTimerWithDuty returns a new eager double linear round timer type for a specific duty and custom clock.
+func NewIncreasingRoundTimerWithDutyAndClock(duty core.Duty, clock clockwork.Clock) RoundTimer {
+	return &increasingRoundTimer{
+		clock: clock,
+		duty:  duty,
+	}
+}
+
 // increasingRoundTimer implements a linear increasing round timerType.
 type increasingRoundTimer struct {
 	clock clockwork.Clock
+	duty  core.Duty
 }
 
 func (increasingRoundTimer) Type() TimerType {
 	return TimerIncreasing
 }
 
 func (t increasingRoundTimer) Timer(round int64) (<-chan time.Time, func()) {
-	timer := t.clock.NewTimer(increasingRoundTimeout(round))
+	timeout := increasingRoundTimeout(round)
+	if proposalTimeoutOptimization(t.duty, round) {
+		timeout = 1500 * time.Millisecond
+	}
+
+	timer := t.clock.NewTimer(timeout)
+
 	return timer.Chan(), func() { timer.Stop() }
 }
 
@@ -121,6 +146,24 @@ func NewDoubleEagerLinearRoundTimerWithClock(clock clockwork.Clock) RoundTimer {
 	}
 }
 
+// NewDoubleEagerLinearRoundTimerWithDuty returns a new eager double linear round timer type for a specific duty.
+func NewDoubleEagerLinearRoundTimerWithDuty(duty core.Duty) RoundTimer {
+	return &doubleEagerLinearRoundTimer{
+		clock:          clockwork.NewRealClock(),
+		duty:           duty,
+		firstDeadlines: make(map[int64]time.Time),
+	}
+}
+
+// NewDoubleEagerLinearRoundTimerWithDutyAndClock returns a new eager double linear round timer type for a specific duty and custom clock.
+func NewDoubleEagerLinearRoundTimerWithDutyAndClock(duty core.Duty, clock clockwork.Clock) RoundTimer {
+	return &doubleEagerLinearRoundTimer{
+		clock:          clock,
+		duty:           duty,
+		firstDeadlines: make(map[int64]time.Time),
+	}
+}
+
 // doubleEagerLinearRoundTimer implements a round timerType with the following properties:
 //
 // It doubles the round duration when a leader is active.
@@ -137,6 +180,7 @@ func NewDoubleEagerLinearRoundTimerWithClock(clock clockwork.Clock) RoundTimer {
 // It is linear, meaning the round duration increases linearly with the round number: 1s, 2s, 3s, etc.
 type doubleEagerLinearRoundTimer struct {
 	clock clockwork.Clock
+	duty  core.Duty
 
 	mu             sync.Mutex
 	firstDeadlines map[int64]time.Time
@@ -150,13 +194,20 @@ func (t *doubleEagerLinearRoundTimer) Timer(round int64) (<-chan time.Time, func
 	t.mu.Lock()
 	defer t.mu.Unlock()
 
+	var timeout time.Duration
+	if proposalTimeoutOptimization(t.duty, round) {
+		timeout = 1500 * time.Millisecond
+	} else {
+		timeout = linearRoundTimeout(round)
+	}
+
 	var deadline time.Time
 	if first, ok := t.firstDeadlines[round]; ok {
 		// Deadline is either double the first timeout
-		deadline = first.Add(linearRoundTimeout(round))
+		deadline = first.Add(timeout)
 	} else {
 		// Or the first timeout
-		deadline = t.clock.Now().Add(linearRoundTimeout(round))
+		deadline = t.clock.Now().Add(timeout)
 		t.firstDeadlines[round] = deadline
 	}
 
@@ -173,22 +224,27 @@ func (t *doubleEagerLinearRoundTimer) Timer(round int64) (<-chan time.Time, func
 // which will increase linearly
 type linearRoundTimer struct {
 	clock clockwork.Clock
+	duty  core.Duty
 }
 
 func (*linearRoundTimer) Type() TimerType {
 	return TimerLinear
 }
 
 func (t *linearRoundTimer) Timer(round int64) (<-chan time.Time, func()) {
-	var timer clockwork.Timer
-	if round == 1 {
+	var timeout time.Duration
+	if proposalTimeoutOptimization(t.duty, round) {
+		timeout = 1500 * time.Millisecond
+	} else if round == 1 {
 		// First round has 1 second
-		timer = t.clock.NewTimer(time.Second)
+		timeout = time.Second
 	} else {
 		// Subsequent rounds have linearly more time starting at 400 milliseconds
-		timer = t.clock.NewTimer(time.Duration(200*(round-1) + 200))
+		timeout = time.Duration(200*(round-1) + 200)
 	}
 
+	timer := t.clock.NewTimer(timeout)
+
 	return timer.Chan(), func() { timer.Stop() }
 }
 
@@ -197,8 +253,25 @@ func NewLinearRoundTimer() RoundTimer {
 	return NewLinearRoundTimerWithClock(clockwork.NewRealClock())
 }
 
+// NewLinearRoundTimerWithClock returns a new linear round timer type with a custom clock.
 func NewLinearRoundTimerWithClock(clock clockwork.Clock) RoundTimer {
 	return &linearRoundTimer{
 		clock: clock,
 	}
 }
+
+// NewLinearRoundTimerWithDuty returns a new linear round timer type for a specific duty.
+func NewLinearRoundTimerWithDuty(duty core.Duty) RoundTimer {
+	return &linearRoundTimer{
+		clock: clockwork.NewRealClock(),
+		duty:  duty,
+	}
+}
+
+// NewLinearRoundTimerWithDutyAndClock returns a new linear round timer type for a specific duty and custom clock.
+func NewLinearRoundTimerWithDutyAndClock(duty core.Duty, clock clockwork.Clock) RoundTimer {
+	return &linearRoundTimer{
+		clock: clock,
+		duty:  duty,
+	}
+}

core/consensus/utils/roundtimer_test.go

@@ -195,3 +195,90 @@ func TestGetTimerFunc(t *testing.T) {
 	require.Equal(t, utils.TimerLinear, timerFunc(core.NewProposerDuty(1)).Type())
 	require.Equal(t, utils.TimerLinear, timerFunc(core.NewProposerDuty(2)).Type())
 }
+
+func TestProposalTimeoutOptimizationIncreasingRoundTimer(t *testing.T) {
+	featureset.EnableForT(t, featureset.ProposalTimeout)
+	defer featureset.DisableForT(t, featureset.ProposalTimeout)
+
+	fakeClock := clockwork.NewFakeClock()
+	duty := core.NewProposerDuty(0)
+	timer := utils.NewIncreasingRoundTimerWithDutyAndClock(duty, fakeClock)
+
+	// First round for proposer should be 1.5s
+	timerC, stop := timer.Timer(1)
+	fakeClock.Advance(1500 * time.Millisecond)
+	select {
+	case <-timerC:
+	default:
+		require.Fail(t, "Timer(round 1, proposer) did not fire at 1.5s")
+	}
+	stop()
+
+	// Second round should use original logic
+	timerC, stop = timer.Timer(2)
+	fakeClock.Advance(utils.IncRoundStart + 2*utils.IncRoundIncrease)
+	select {
+	case <-timerC:
+	default:
+		require.Fail(t, "Timer(round 2, proposer) did not fire at original duration")
+	}
+	stop()
+}
+
+func TestProposalTimeoutOptimizationDoubleEagerLinearRoundTimer(t *testing.T) {
+	featureset.EnableForT(t, featureset.ProposalTimeout)
+	defer featureset.DisableForT(t, featureset.ProposalTimeout)
+
+	fakeClock := clockwork.NewFakeClock()
+	duty := core.NewProposerDuty(0)
+	timer := utils.NewDoubleEagerLinearRoundTimerWithDutyAndClock(duty, fakeClock)
+
+	// First round for proposer should be 1.5s
+	timerC, stop := timer.Timer(1)
+	fakeClock.Advance(1500 * time.Millisecond)
+	select {
+	case <-timerC:
+	default:
+		require.Fail(t, "Timer(round 1, proposer) did not fire at 1.5s")
+	}
+	stop()
+
+	// Second round should use original logic (2s)
+	timerC, stop = timer.Timer(2)
+	fakeClock.Advance(2 * time.Second)
+	select {
+	case <-timerC:
+	default:
+		require.Fail(t, "Timer(round 2, proposer) did not fire at 2s")
+	}
+	stop()
+}
+
+func TestProposalTimeoutOptimizationLinearRoundTimer(t *testing.T) {
+	featureset.EnableForT(t, featureset.ProposalTimeout)
+	defer featureset.DisableForT(t, featureset.ProposalTimeout)
+
+	fakeClock := clockwork.NewFakeClock()
+	duty := core.NewProposerDuty(0)
+	timer := utils.NewLinearRoundTimerWithDutyAndClock(duty, fakeClock)
+
+	// First round for proposer should be 1.5s
+	timerC, stop := timer.Timer(1)
+	fakeClock.Advance(1500 * time.Millisecond)
+	select {
+	case <-timerC:
+	default:
+		require.Fail(t, "Timer(round 1, proposer) did not fire at 1.5s")
+	}
+	stop()
+
+	// Third round should use original logic (600ms)
+	timerC, stop = timer.Timer(3)
+	fakeClock.Advance(600 * time.Millisecond)
+	select {
+	case <-timerC:
+	default:
+		require.Fail(t, "Timer(round 3, proposer) did not fire at 600ms")
+	}
+	stop()
+}