《MMO 服务器开发》9.2 性能预算达标

// snippet: internal/dawnrealm/budget.go 的预算定义与判定
// Budget is the acceptance threshold set for one 《晨曦大陆》 process.
type Budget struct {
	MaxTickMs float64 `json:"max_tick_ms"` // per-tick frame budget
	MinConns  int     `json:"min_conns"`   // concurrent connections per process
	MaxP99Ms  float64 `json:"max_p99_ms"`  // request round-trip P99
}

// Evaluate applies the budget gates to a report and records every miss.
func (b Budget) Evaluate(r *Report) {
	r.Failures = nil
	if r.TickP99Ms > b.MaxTickMs {
		r.Failures = append(r.Failures, fmt.Sprintf("tick p99 %.2fms > %.2fms", r.TickP99Ms, b.MaxTickMs))
	}
	if r.Conns < b.MinConns {
		r.Failures = append(r.Failures, fmt.Sprintf("conns %d < %d", r.Conns, b.MinConns))
	}
	if r.LatencyP99Ms > b.MaxP99Ms {
		r.Failures = append(r.Failures, fmt.Sprintf("latency p99 %.2fms > %.2fms", r.LatencyP99Ms, b.MaxP99Ms))
	}
	r.Pass = len(r.Failures) == 0
}

// file: internal/dawnrealm/budget_test.go
// tier: B
// verify: go test -run TestBudgetPass -v ./internal/dawnrealm/
package dawnrealm

import (
	"encoding/json"
	"fmt"
	"net"
	"testing"
	"time"
)

func TestFrameRoundTrip(t *testing.T) {
	raw := Encode(Frame{Cmd: CmdHeartbeatReq, Seq: 42, Payload: []byte("hi")})
	if len(raw) != HeaderSize+2 {
		t.Fatalf("frame len = %d, want %d", len(raw), HeaderSize+2)
	}
	if got := int(raw[3]); got != 9 {
		t.Fatalf("length field = %d, want 9", got)
	}
}

// startEcho is a real TCP server that answers heartbeat frames. It is the load
// target for the latency half of the budget.
func startEcho(t *testing.T) (addr string, stop func()) {
	t.Helper()
	ln, err := net.Listen("tcp", "127.0.0.1:0")
	if err != nil {
		t.Fatal(err)
	}
	go func() {
		for {
			c, err := ln.Accept()
			if err != nil {
				return
			}
			go func(conn net.Conn) {
				defer conn.Close()
				for {
					f, err := ReadFrame(conn)
					if err != nil {
						return
					}
					if f.Cmd == CmdHeartbeatReq {
						_, _ = conn.Write(Encode(Frame{Cmd: CmdHeartbeatResp, Seq: f.Seq}))
					}
				}
			}(c)
		}
	}()
	return ln.Addr().String(), func() { _ = ln.Close() }
}

// TestBudgetPass runs one load and applies the hard budget gates. It follows
// the three benchmark disciplines: separate processes (client/server split),
// warm up before counting, and report same-machine relative magnitudes only.
func TestBudgetPass(t *testing.T) {
	const entities = 10000
	scene := NewScene(1, entities)

	// Discipline 2: warm up to a steady state before counting ticks.
	for i := 0; i < 200; i++ {
		scene.Tick(0.05)
	}
	const ticks = 1000
	tickSamples := make([]float64, 0, ticks)
	for i := 0; i < ticks; i++ {
		start := time.Now()
		scene.Tick(0.05)
		tickSamples = append(tickSamples, float64(time.Since(start).Microseconds())/1000.0)
	}

	addr, stop := startEcho(t)
	defer stop()

	// Discipline 1: the client is a separate connection set, not the scene.
	const conns = 400
	peers := make([]net.Conn, 0, conns)
	for i := 0; i < conns; i++ {
		c, err := net.Dial("tcp", addr)
		if err != nil {
			t.Fatalf("dial %d: %v", i, err)
		}
		peers = append(peers, c)
		if i%32 == 31 {
			time.Sleep(time.Millisecond) // stagger past the small listen backlog
		}
	}
	defer func() {
		for _, c := range peers {
			_ = c.Close()
		}
	}()

	// Warm the request path before measuring latency.
	latSamples := make([]float64, 0, conns*8)
	for _, c := range peers {
		_ = c.SetDeadline(time.Now().Add(2 * time.Second))
		_, _ = c.Write(Encode(Frame{Cmd: CmdHeartbeatReq, Seq: 0}))
		_, _ = ReadFrame(c)
	}
	for round := 0; round < 8; round++ {
		for _, c := range peers {
			_ = c.SetDeadline(time.Now().Add(2 * time.Second))
			start := time.Now()
			_, _ = c.Write(Encode(Frame{Cmd: CmdHeartbeatReq, Seq: uint32(round)}))
			if _, err := ReadFrame(c); err != nil {
				t.Fatalf("heartbeat: %v", err)
			}
			latSamples = append(latSamples, float64(time.Since(start).Microseconds())/1000.0)
		}
	}

	maxTick := 0.0
	for _, v := range tickSamples {
		if v > maxTick {
			maxTick = v
		}
	}
	rep := Report{
		TickP50Ms:    Percentile(tickSamples, 0.50),
		TickP99Ms:    Percentile(tickSamples, 0.99),
		TickMaxMs:    maxTick,
		Conns:        len(peers),
		LatencyP50Ms: Percentile(latSamples, 0.50),
		LatencyP99Ms: Percentile(latSamples, 0.99),
		Entities:     entities,
	}
	budget := Budget{MaxTickMs: 33, MinConns: 300, MaxP99Ms: 20}
	budget.Evaluate(&rep)

	buf, _ := json.MarshalIndent(rep, "", "  ")
	fmt.Println(string(buf))
	t.Logf("tick p99=%.3fms conns=%d latency p99=%.3fms pass=%v",
		rep.TickP99Ms, rep.Conns, rep.LatencyP99Ms, rep.Pass)

	if !rep.Pass {
		t.Fatalf("budget not met: %v", rep.Failures)
	}
}

{
  "tick_p50_ms": 0.128,
  "tick_p99_ms": 0.175,
  "tick_max_ms": 0.237,
  "conns": 400,
  "latency_p50_ms": 0.3,
  "latency_p99_ms": 1.713,
  "entities": 10000,
  "pass": true
}