Update rate

Author: mohanson

lib/rate/cmd/race/main.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"context"
+	"math/rand/v2"
+	"time"
+
+	"github.com/mohanson/daze/lib/rate"
+)
+
+const (
+	cGo     = 4
+	cLimNum = 128
+	cLimPer = time.Millisecond
+	cTx     = time.Second * 4
+)
+
+func main() {
+	lim := rate.NewLimits(cLimNum, cLimPer)
+	ctx, fin := context.WithTimeout(context.Background(), cTx)
+	for range cGo {
+		go func() {
+			for {
+				select {
+				case <-ctx.Done():
+					return
+				default:
+					maxn := uint64(cLimNum) * 2
+					step := rand.Uint64() % maxn
+					lim.Wait(step)
+				}
+			}
+		}()
+	}
+	<-ctx.Done()
+	fin()
+}

lib/rate/rate.go

@@ -18,9 +18,23 @@ type Limits struct {
 	step     time.Duration
 }
 
+// Peek glances there are enough resources (n) available.
+func (l *Limits) Peek(n uint64) bool {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	cycles := uint64(time.Since(l.last) / l.step)
+	if cycles > 0 {
+		l.last = l.last.Add(l.step * time.Duration(cycles))
+		doa.Doa(cycles <= math.MaxUint64/l.addition)
+		doa.Doa(l.size <= math.MaxUint64-l.addition*cycles)
+		l.size = l.size + l.addition*cycles
+		l.size = min(l.size, l.capacity)
+	}
+	return l.size >= n
+}
+
 // Wait ensures there are enough resources (n) available, blocking if necessary.
 func (l *Limits) Wait(n uint64) {
-	doa.Doa(n < math.MaxUint64/2)
 	l.mu.Lock()
 	defer l.mu.Unlock()
 	cycles := uint64(time.Since(l.last) / l.step)
@@ -44,9 +58,8 @@ func (l *Limits) Wait(n uint64) {
 // NewLimits creates a new rate limiter with rate r over period p.
 func NewLimits(r uint64, p time.Duration) *Limits {
 	doa.Doa(r > 0)
-	doa.Doa(r < math.MaxUint64/2)
 	doa.Doa(p > 0)
-	g := func(a, b uint64) uint64 {
+	gcd := func(a, b uint64) uint64 {
 		t := uint64(0)
 		for b != 0 {
 			t = b
@@ -55,14 +68,12 @@ func NewLimits(r uint64, p time.Duration) *Limits {
 		}
 		return a
 	}(r, uint64(p))
-	a := r / g
-	s := p / time.Duration(g)
 	return &Limits{
-		addition: a,
+		addition: r / gcd,
 		capacity: r,
 		last:     time.Now(),
 		mu:       sync.Mutex{},
 		size:     r,
-		step:     s,
+		step:     p / time.Duration(gcd),
 	}
 }