106 lines
3.3 KiB
Go
106 lines
3.3 KiB
Go
package gateway
|
|
|
|
import (
|
|
"sort"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
type syntheticPacerDelivery struct {
|
|
at time.Time
|
|
flow string
|
|
bytes int64
|
|
}
|
|
|
|
func TestFairPacerEightFlowSharesAndCapacitySteps(t *testing.T) {
|
|
start := time.Date(2026, time.January, 1, 0, 0, 0, 0, time.UTC)
|
|
flows := []string{"one", "two", "three", "four", "five", "six", "seven", "eight"}
|
|
pacer := newFairPacer(8000)
|
|
next := make(map[string]time.Time, len(flows))
|
|
baseline := runSyntheticPacer(pacer, start, start.Add(60*time.Second), flows, next)
|
|
assertSyntheticFairness(t, baseline, flows)
|
|
assertSyntheticCap(t, baseline, 1_000_000)
|
|
|
|
pacer.setKbps(6000)
|
|
quarter := runSyntheticPacer(pacer, start.Add(60*time.Second), start.Add(70*time.Second), flows, next)
|
|
assertSyntheticFairness(t, quarter, flows)
|
|
assertSyntheticCap(t, quarter, 750_000)
|
|
|
|
pacer.setKbps(4000)
|
|
half := runSyntheticPacer(pacer, start.Add(70*time.Second), start.Add(80*time.Second), flows, next)
|
|
assertSyntheticFairness(t, half, flows)
|
|
assertSyntheticCap(t, half, 500_000)
|
|
}
|
|
|
|
func TestFairPacerBoundsCatchupAfterHostStall(t *testing.T) {
|
|
start := time.Date(2026, time.January, 1, 0, 0, 0, 0, time.UTC)
|
|
pacer := newFairPacer(8000)
|
|
_ = pacer.reserveAt(start, "one", 1000)
|
|
resumed := start.Add(100 * time.Millisecond)
|
|
next := pacer.reserveAt(resumed, "one", 1000)
|
|
if next.Before(resumed.Add(-fairPacerMaximumCatchup)) || next.After(resumed.Add(10*time.Millisecond)) {
|
|
t.Fatalf("post-stall reservation = %s, want bounded catchup near %s", next, resumed)
|
|
}
|
|
}
|
|
|
|
func runSyntheticPacer(pacer *fairPacer, start, end time.Time, flows []string, next map[string]time.Time) []syntheticPacerDelivery {
|
|
const packetBytes = 1000
|
|
for _, flow := range flows {
|
|
if next[flow].IsZero() {
|
|
next[flow] = pacer.reserveAt(start, flow, packetBytes)
|
|
}
|
|
}
|
|
var deliveries []syntheticPacerDelivery
|
|
for {
|
|
flow := ""
|
|
at := end.Add(time.Nanosecond)
|
|
for _, candidate := range flows {
|
|
if next[candidate].Before(at) {
|
|
flow, at = candidate, next[candidate]
|
|
}
|
|
}
|
|
if at.After(end) {
|
|
return deliveries
|
|
}
|
|
deliveries = append(deliveries, syntheticPacerDelivery{at: at, flow: flow, bytes: packetBytes})
|
|
next[flow] = pacer.reserveAt(at, flow, packetBytes)
|
|
}
|
|
}
|
|
|
|
func assertSyntheticFairness(t *testing.T, deliveries []syntheticPacerDelivery, flows []string) {
|
|
t.Helper()
|
|
counts := make(map[string]int64, len(flows))
|
|
for _, delivery := range deliveries {
|
|
counts[delivery.flow] += delivery.bytes
|
|
}
|
|
total := int64(0)
|
|
for _, flow := range flows {
|
|
total += counts[flow]
|
|
}
|
|
target := total / int64(len(flows))
|
|
for _, flow := range flows {
|
|
delta := counts[flow] - target
|
|
if delta < 0 {
|
|
delta = -delta
|
|
}
|
|
if target == 0 || float64(delta)/float64(target) > 0.10 {
|
|
t.Fatalf("flow %s share=%d target=%d", flow, counts[flow], target)
|
|
}
|
|
}
|
|
}
|
|
|
|
func assertSyntheticCap(t *testing.T, deliveries []syntheticPacerDelivery, bytesPerSecond int64) {
|
|
t.Helper()
|
|
sort.Slice(deliveries, func(first, second int) bool { return deliveries[first].at.Before(deliveries[second].at) })
|
|
for first, total, last := 0, int64(0), 0; first < len(deliveries); first++ {
|
|
for last < len(deliveries) && deliveries[last].at.Sub(deliveries[first].at) <= 5*time.Second {
|
|
total += deliveries[last].bytes
|
|
last++
|
|
}
|
|
if total > bytesPerSecond*5*105/100 {
|
|
t.Fatalf("five-second egress=%d exceeds cap=%d", total, bytesPerSecond*5)
|
|
}
|
|
total -= deliveries[first].bytes
|
|
}
|
|
}
|