feat: optimize jitter factor calculation

tm2/pkg/p2p/switch.go

@@ -1,11 +1,12 @@
 package p2p
 
 import (
+	"bytes"
 	"context"
 	"crypto/rand"
+	"encoding/binary"
 	"fmt"
 	"math"
-	"math/big"
 	"sync"
 	"time"
 
@@ -482,65 +483,69 @@
 	}
 }
 
-// calculateBackoff calculates a backoff time,
-// based on the number of attempts and range limits
+// calculateBackoff calculates the backoff interval by exponentiating the base interval
+// by the number of attempts. The returned interval is capped at maxInterval and has a
+// jitter factor applied to it (+/- 10% of interval, max 10 sec).
 func calculateBackoff(
 	attempts int,
-	minTimeout time.Duration,
-	maxTimeout time.Duration,
+	baseInterval time.Duration,
+	maxInterval time.Duration,
 ) time.Duration {
-	var (
-		minTime    = time.Second * 1
-		maxTime    = time.Second * 60
-		multiplier = float64(2) // exponential
+	const (
+		defaultBaseInterval = time.Second * 1
+		defaultMaxInterval  = time.Second * 60
 	)
 
-	// Check the min limit
-	if minTimeout > 0 {
-		minTime = minTimeout
+	// Sanitize base interval parameter.
+	if baseInterval <= 0 {
+		baseInterval = defaultBaseInterval
 	}
 
-	// Check the max limit
-	if maxTimeout > 0 {
-		maxTime = maxTimeout
+	// Sanitize max interval parameter.
+	if maxInterval <= 0 {
+		maxInterval = defaultMaxInterval
 	}
 
-	// Sanity check the range
-	if minTime >= maxTime {
-		return maxTime
+	// Calculate the interval by exponentiating the base interval by the number of attempts.
+	interval := baseInterval << attempts
+
+	// Cap the interval to the maximum interval.
+	if interval > maxInterval {
+		interval = maxInterval
 	}
 
-	// Calculate the backoff duration
-	var (
-		base       = float64(minTime)
-		calculated = base * math.Pow(multiplier, float64(attempts))
-	)
+	// Below is the code to add a jitter factor to the interval.
+	// Read random bytes into an 8 bytes buffer (size of an int64).
+	var randBytes [8]byte
+	_, err := rand.Read(randBytes[:])
+	if err != nil {
+		return interval
+	}
 
-	// Attempt to calculate the jitter factor
-	n, err := rand.Int(rand.Reader, big.NewInt(math.MaxInt64))
-	if err == nil {
-		jitterFactor := float64(n.Int64()) / float64(math.MaxInt64) // range [0, 1]
+	// Convert the random bytes to an int64.
+	var randInt64 int64
+	_ = binary.Read(bytes.NewReader(randBytes[:]), binary.NativeEndian, &randInt64)
 
-		calculated = jitterFactor*(calculated-base) + base
-	}
+	// Calculate the random jitter multiplier (float between -1 and 1).
+	jitterMultiplier := float64(randInt64) / float64(math.MaxInt64)
 
-	// Prevent overflow for int64 (duration) cast
-	if calculated > float64(math.MaxInt64) {
-		return maxTime
-	}
+	const (
+		maxJitterDuration   = 10 * time.Second
+		maxJitterPercentage = 10 // 10%
+	)
 
-	duration := time.Duration(calculated)
+	// Calculate the maximum jitter based on interval percentage.
+	maxJitter := interval * maxJitterPercentage / 100
 
-	// Clamp the duration within bounds
-	if duration < minTime {
-		return minTime
+	// Cap the maximum jitter to the maximum duration.
+	if maxJitter > maxJitterDuration {
+		maxJitter = maxJitterDuration
 	}
 
-	if duration > maxTime {
-		return maxTime
-	}
+	// Calculate the jitter.
+	jitter := time.Duration(float64(maxJitter) * jitterMultiplier)
 
-	return duration
+	return interval + jitter
 }
 
 // DialPeers adds the peers to the dial queue for async dialing.