offset.go

package equalizer

import (
	"math/rand"
	"sync/atomic"
)

// The Offset component is responsible for advancing the head position of the
// Equalizer tape after each request. Implementations of Offset must be thread-safe.
type Offset interface {
	NextIndex() int
}

// RandomOffset is an offset manager that uses a random-based offset approach.
type RandomOffset struct {
	Len int
}

var _ Offset = (*RandomOffset)(nil)

// NewRandomOffset returns a new RandomOffset, where len is the bitmap tape length.
func NewRandomOffset(len int) *RandomOffset {
	return &RandomOffset{Len: len}
}

// NextIndex returns the next random index within a tape.
func (ro *RandomOffset) NextIndex() int {
	return rand.Intn(ro.Len)
}

// StepOffset is an offset manager that uses a fixed step approach.
type StepOffset struct {
	Len  int
	Step int64
	prev atomic.Int64
}

var _ Offset = (*StepOffset)(nil)

// NewStepOffset allocates and returns a new StepOffset, where len is the length
// of the bitmap tape and step is the offset to be taken from the previous position.
func NewStepOffset(len, step int) *StepOffset {
	return &StepOffset{
		Len:  len,
		Step: int64(step),
	}
}

// NextIndex returns the next index in a round-robin fashion,
// utilizing the specified step value to advance along the tape.
func (so *StepOffset) NextIndex() int {
	return int(so.prev.Add(so.Step)) % so.Len
}