Files
mtusi2026lab6/service/cmd/benchmark/main.go
T
2026-11-17 13:08:13 +03:00

261 lines
7.9 KiB
Go

// Command benchmark generates paced lab5 traffic through the public load balancer.
package main
import (
"bytes"
"encoding/json"
"flag"
"fmt"
"io"
"math"
"net/http"
"os"
"slices"
"strings"
"sync"
"sync/atomic"
"time"
"github.com/google/uuid"
)
type client struct {
base, token string
http *http.Client
}
func (c *client) call(method, path string, body any, key string) (map[string]any, int, error) {
var data io.Reader
if body != nil {
b, e := json.Marshal(body)
if e != nil {
return nil, 0, e
}
data = bytes.NewReader(b)
}
req, e := http.NewRequest(method, c.base+path, data)
if e != nil {
return nil, 0, e
}
if body != nil {
req.Header.Set("Content-Type", "application/json")
}
if c.token != "" {
req.Header.Set("Authorization", "Bearer "+c.token)
}
if key != "" {
req.Header.Set("Idempotency-Key", key)
}
// net/http otherwise treats Idempotency-Key + GetBody as permission to retry POST.
if method == http.MethodPost {
req.GetBody = nil
}
resp, e := c.http.Do(req)
if e != nil {
return nil, 0, e
}
defer resp.Body.Close()
b, e := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
if e != nil {
return nil, resp.StatusCode, e
}
if resp.StatusCode != 200 && resp.StatusCode != 201 {
return nil, resp.StatusCode, fmt.Errorf("HTTP %d", resp.StatusCode)
}
var out map[string]any
e = json.Unmarshal(b, &out)
return out, resp.StatusCode, e
}
func (c *client) setup(seed int) (string, error) {
username := "bench_" + strings.ReplaceAll(uuid.NewString(), "-", "")[:20]
password := "Synthetic-benchmark-123"
user, _, e := c.call("POST", "/api/v1/users", map[string]string{"username": username, "display_name": "Benchmark", "password": password}, "")
if e != nil {
return "", e
}
req, _ := http.NewRequest("POST", c.base+"/api/v1/auth/sessions", nil)
req.SetBasicAuth(username, password)
resp, e := c.http.Do(req)
if e != nil {
return "", e
}
var session struct {
Token string `json:"token"`
}
e = json.NewDecoder(resp.Body).Decode(&session)
resp.Body.Close()
if e != nil || resp.StatusCode != 201 || session.Token == "" {
return "", fmt.Errorf("login status %d: %v", resp.StatusCode, e)
}
c.token = session.Token
chat, _, e := c.call("POST", "/api/v1/chats", map[string]any{"title": "Benchmark", "member_ids": []any{user["id"]}}, "")
if e != nil {
return "", e
}
path := "/api/v1/chats/" + chat["id"].(string) + "/messages"
// Bounded concurrent setup is excluded from the measured interval.
var group sync.WaitGroup
slots := make(chan struct{}, 8)
errs := make(chan error, seed)
for i := range seed {
slots <- struct{}{}
group.Go(func() {
defer func() { <-slots }()
_, _, e := c.call("POST", path, map[string]string{"text": fmt.Sprintf("seed-%d", i)}, uuid.NewString())
if e != nil {
errs <- e
}
})
}
group.Wait()
close(errs)
for e := range errs {
if e != nil {
return "", e
}
}
return path, nil
}
type result struct {
MeasurementUnix float64 `json:"measurement_started_unix"`
Label string `json:"label"`
TargetRate int `json:"target_rps"`
Duration float64 `json:"duration_seconds"`
Elapsed float64 `json:"elapsed_including_drain_seconds"`
Scheduled int `json:"scheduled"`
Dropped int `json:"generator_dropped"`
Success int `json:"successful_requests"`
Errors int `json:"failed_requests"`
ReadSuccess int `json:"read_success"`
WriteSuccess int `json:"write_success"`
SuccessfulRPS float64 `json:"successful_rps"`
ErrorRatio float64 `json:"error_ratio_including_drops"`
Latency map[string]float64 `json:"successful_latency_ms"`
Statuses map[int]int `json:"statuses"`
PeakInFlight int64 `json:"peak_in_flight"`
Note string `json:"note"`
}
func phase(c *client, path string, rate int, duration time.Duration, maxInFlight int, label string) result {
out := result{Label: label, TargetRate: rate, Duration: duration.Seconds(), Statuses: map[int]int{}, Latency: map[string]float64{}, Note: "Paced open-loop, 10ms dispatch batches; 90% first-page GET, 10% POST; no POST retries. Percentiles of successes include scheduler delay; failures and capacity drops reported separately. RPS denominator includes drain."}
start := time.Now()
out.MeasurementUnix = float64(start.UnixNano()) / 1e9
end := start.Add(duration)
slots := make(chan struct{}, maxInFlight)
var group sync.WaitGroup
var mu sync.Mutex
var active atomic.Int64
var peak atomic.Int64
latencies := make([]float64, 0, rate*int(duration.Seconds()))
index := 0
for tick := 0; ; tick++ {
now := time.Now()
if !now.Before(end) {
break
}
target := start.Add(time.Duration(tick) * 10 * time.Millisecond)
if target.After(now) {
time.Sleep(time.Until(target))
}
until := min(int(time.Since(start).Seconds()*float64(rate))+1, int(duration.Seconds()*float64(rate)))
for index < until {
i := index
index++
out.Scheduled++
scheduled := start.Add(time.Duration(float64(i) / float64(rate) * float64(time.Second)))
select {
case slots <- struct{}{}:
group.Go(func() {
n := active.Add(1)
for old := peak.Load(); n > old; old = peak.Load() {
if peak.CompareAndSwap(old, n) {
break
}
}
defer func() { active.Add(-1); <-slots }()
method, p := "GET", path+"?limit=50"
var body any
key := ""
if i%10 == 0 {
method = "POST"
p = path
key = uuid.NewString()
body = map[string]string{"text": key}
}
_, status, err := c.call(method, p, body, key)
latency := float64(time.Since(scheduled).Microseconds()) / 1000
mu.Lock()
defer mu.Unlock()
out.Statuses[status]++
if err != nil {
out.Errors++
} else {
out.Success++
if method == "GET" {
out.ReadSuccess++
} else {
out.WriteSuccess++
}
latencies = append(latencies, max(0, latency))
}
})
default:
out.Dropped++
}
}
}
group.Wait()
out.Elapsed = time.Since(start).Seconds()
out.PeakInFlight = peak.Load()
out.SuccessfulRPS = float64(out.Success) / out.Elapsed
if out.Scheduled > 0 {
out.ErrorRatio = float64(out.Errors+out.Dropped) / float64(out.Scheduled)
}
slices.Sort(latencies)
for name, p := range map[string]float64{"p50": .5, "p95": .95, "p99": .99} {
if len(latencies) > 0 {
out.Latency[name] = latencies[max(0, int(math.Ceil(p*float64(len(latencies))))-1)]
}
}
return out
}
func main() {
base := flag.String("base-url", "http://localhost:18086", "public LB URL")
rate := flag.Int("rate", 100, "scheduled requests per second")
duration := flag.Duration("duration", 30*time.Second, "measured time")
warmup := flag.Duration("warmup", 5*time.Second, "warmup excluded from results")
seed := flag.Int("seed", 1000, "initial messages")
maxFlight := flag.Int("max-in-flight", 256, "bounded in-flight limit")
label := flag.String("label", "manual", "case label")
output := flag.String("output", "", "JSON destination")
flag.Parse()
if *rate < 1 || *rate > 100000 || *duration <= 0 || *warmup < 0 || *maxFlight < 1 || *seed < 0 {
fmt.Fprintln(os.Stderr, "invalid benchmark settings")
os.Exit(2)
}
c := &client{base: *base, http: &http.Client{Timeout: 2 * time.Second, Transport: &http.Transport{MaxIdleConns: 512, MaxIdleConnsPerHost: 512, MaxConnsPerHost: *maxFlight, IdleConnTimeout: 60 * time.Second}}}
path, e := c.setup(*seed)
if e != nil {
fmt.Fprintln(os.Stderr, "setup:", e)
os.Exit(1)
}
if *warmup > 0 {
phase(c, path, *rate, *warmup, *maxFlight, "warmup")
}
row := phase(c, path, *rate, *duration, *maxFlight, *label)
b, e := json.MarshalIndent(row, "", " ")
if e != nil {
panic(e)
}
if *output != "" {
if e = os.WriteFile(*output, append(b, '\n'), 0644); e != nil {
panic(e)
}
}
fmt.Println(string(b))
if row.Success == 0 {
os.Exit(1)
}
}