forked from ethereum/go-ethereum
-
Notifications
You must be signed in to change notification settings - Fork 276
Commit
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
Merge branch 'syncUpstream/active' into syncUpstream/rever_drop_eth66
- Loading branch information
Showing
47 changed files
with
2,600 additions
and
184 deletions.
There are no files selected for viewing
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,51 @@ | ||
| package backoff | ||
|
|
||
| import ( | ||
| "math" | ||
| "math/rand" | ||
| "time" | ||
| ) | ||
|
|
||
| // Exponential is a backoff strategy that increases the delay between retries exponentially. | ||
| type Exponential struct { | ||
| attempt int | ||
|
|
||
| maxJitter time.Duration | ||
|
|
||
| min time.Duration | ||
| max time.Duration | ||
| } | ||
|
|
||
| func NewExponential(minimum, maximum, maxJitter time.Duration) *Exponential { | ||
| return &Exponential{ | ||
| min: minimum, | ||
| max: maximum, | ||
| maxJitter: maxJitter, | ||
| } | ||
| } | ||
|
|
||
| func (e *Exponential) NextDuration() time.Duration { | ||
| var jitter time.Duration | ||
| if e.maxJitter > 0 { | ||
| jitter = time.Duration(rand.Int63n(e.maxJitter.Nanoseconds())) | ||
| } | ||
|
|
||
| minFloat := float64(e.min) | ||
| duration := math.Pow(2, float64(e.attempt)) * minFloat | ||
|
|
||
| // limit at configured maximum | ||
| if duration > float64(e.max) { | ||
| duration = float64(e.max) | ||
| } | ||
|
|
||
| e.attempt++ | ||
| return time.Duration(duration) + jitter | ||
| } | ||
|
|
||
| func (e *Exponential) Reset() { | ||
| e.attempt = 0 | ||
| } | ||
|
|
||
| func (e *Exponential) Attempt() int { | ||
| return e.attempt | ||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,39 @@ | ||
| package backoff | ||
|
|
||
| import ( | ||
| "testing" | ||
| "time" | ||
|
|
||
| "github.com/stretchr/testify/require" | ||
| ) | ||
|
|
||
| func TestExponentialBackoff(t *testing.T) { | ||
| t.Run("Multiple attempts", func(t *testing.T) { | ||
| e := NewExponential(100*time.Millisecond, 10*time.Second, 0) | ||
| expectedDurations := []time.Duration{ | ||
| 100 * time.Millisecond, | ||
| 200 * time.Millisecond, | ||
| 400 * time.Millisecond, | ||
| 800 * time.Millisecond, | ||
| 1600 * time.Millisecond, | ||
| 3200 * time.Millisecond, | ||
| 6400 * time.Millisecond, | ||
| 10 * time.Second, // capped at max | ||
| } | ||
| for i, expected := range expectedDurations { | ||
| require.Equal(t, expected, e.NextDuration(), "attempt %d", i) | ||
| } | ||
| }) | ||
|
|
||
| t.Run("Jitter added", func(t *testing.T) { | ||
| e := NewExponential(1*time.Second, 10*time.Second, 1*time.Second) | ||
| duration := e.NextDuration() | ||
| require.GreaterOrEqual(t, duration, 1*time.Second) | ||
| require.Less(t, duration, 2*time.Second) | ||
| }) | ||
|
|
||
| t.Run("Edge case: min > max", func(t *testing.T) { | ||
| e := NewExponential(10*time.Second, 5*time.Second, 0) | ||
| require.Equal(t, 5*time.Second, e.NextDuration()) | ||
| }) | ||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,109 @@ | ||
| package common | ||
|
|
||
| import ( | ||
| "container/heap" | ||
| ) | ||
|
|
||
| // Heap is a generic min-heap (or max-heap, depending on Comparable behavior) implementation. | ||
| type Heap[T Comparable[T]] struct { | ||
| heap innerHeap[T] | ||
| } | ||
|
|
||
| func NewHeap[T Comparable[T]]() *Heap[T] { | ||
| return &Heap[T]{ | ||
| heap: make(innerHeap[T], 0), | ||
| } | ||
| } | ||
|
|
||
| func (h *Heap[T]) Len() int { | ||
| return len(h.heap) | ||
| } | ||
|
|
||
| func (h *Heap[T]) Push(element T) *HeapElement[T] { | ||
| heapElement := NewHeapElement(element) | ||
| heap.Push(&h.heap, heapElement) | ||
|
|
||
| return heapElement | ||
| } | ||
|
|
||
| func (h *Heap[T]) Pop() *HeapElement[T] { | ||
| return heap.Pop(&h.heap).(*HeapElement[T]) | ||
| } | ||
|
|
||
| func (h *Heap[T]) Peek() *HeapElement[T] { | ||
| if h.Len() == 0 { | ||
| return nil | ||
| } | ||
|
|
||
| return h.heap[0] | ||
| } | ||
|
|
||
| func (h *Heap[T]) Remove(element *HeapElement[T]) { | ||
| heap.Remove(&h.heap, element.index) | ||
| } | ||
|
|
||
| func (h *Heap[T]) Clear() { | ||
| h.heap = make(innerHeap[T], 0) | ||
| } | ||
|
|
||
| type innerHeap[T Comparable[T]] []*HeapElement[T] | ||
|
|
||
| func (h innerHeap[T]) Len() int { | ||
| return len(h) | ||
| } | ||
|
|
||
| func (h innerHeap[T]) Less(i, j int) bool { | ||
| return h[i].Value().CompareTo(h[j].Value()) < 0 | ||
| } | ||
|
|
||
| func (h innerHeap[T]) Swap(i, j int) { | ||
| h[i], h[j] = h[j], h[i] | ||
| h[i].index, h[j].index = i, j | ||
| } | ||
|
|
||
| func (h *innerHeap[T]) Push(x interface{}) { | ||
| data := x.(*HeapElement[T]) | ||
| *h = append(*h, data) | ||
| data.index = len(*h) - 1 | ||
| } | ||
|
|
||
| func (h *innerHeap[T]) Pop() interface{} { | ||
| n := len(*h) | ||
| element := (*h)[n-1] | ||
| (*h)[n-1] = nil // avoid memory leak | ||
| *h = (*h)[:n-1] | ||
| element.index = -1 | ||
|
|
||
| return element | ||
| } | ||
|
|
||
| // Comparable is an interface for types that can be compared. | ||
| type Comparable[T any] interface { | ||
| // CompareTo compares x with other. | ||
| // To create a min heap, return: | ||
| // -1 if x < other | ||
| // 0 if x == other | ||
| // +1 if x > other | ||
| // To create a max heap, return the opposite. | ||
| CompareTo(other T) int | ||
| } | ||
|
|
||
| // HeapElement is a wrapper around the value stored in the heap. | ||
| type HeapElement[T Comparable[T]] struct { | ||
| value T | ||
| index int | ||
| } | ||
|
|
||
| func NewHeapElement[T Comparable[T]](value T) *HeapElement[T] { | ||
| return &HeapElement[T]{ | ||
| value: value, | ||
| } | ||
| } | ||
|
|
||
| func (h *HeapElement[T]) Value() T { | ||
| return h.value | ||
| } | ||
|
|
||
| func (h *HeapElement[T]) Index() int { | ||
| return h.index | ||
| } |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Original file line number | Diff line number | Diff line change |
|---|---|---|
| @@ -0,0 +1,40 @@ | ||
| package common | ||
|
|
||
| import ( | ||
| "testing" | ||
|
|
||
| "github.com/stretchr/testify/require" | ||
| ) | ||
|
|
||
| type Int int | ||
|
|
||
| func (i Int) CompareTo(other Int) int { | ||
| if i < other { | ||
| return -1 | ||
| } else if i > other { | ||
| return 1 | ||
| } else { | ||
| return 0 | ||
| } | ||
| } | ||
|
|
||
| func TestHeap(t *testing.T) { | ||
| h := NewHeap[Int]() | ||
|
|
||
| require.Equal(t, 0, h.Len(), "Heap should be empty initially") | ||
|
|
||
| h.Push(Int(3)) | ||
| h.Push(Int(1)) | ||
| h.Push(Int(2)) | ||
|
|
||
| require.Equal(t, 3, h.Len(), "Heap should have three elements after pushing") | ||
|
|
||
| require.EqualValues(t, 1, h.Pop(), "Pop should return the smallest element") | ||
| require.Equal(t, 2, h.Len(), "Heap should have two elements after popping") | ||
|
|
||
| require.EqualValues(t, 2, h.Pop(), "Pop should return the next smallest element") | ||
| require.Equal(t, 1, h.Len(), "Heap should have one element after popping") | ||
|
|
||
| require.EqualValues(t, 3, h.Pop(), "Pop should return the last element") | ||
| require.Equal(t, 0, h.Len(), "Heap should be empty after popping all elements") | ||
| } |
Oops, something went wrong.