《游戏服务端架构·品类、状态与拓扑》1.2 三类延迟预算：帧、操作、结算

客户端输入 → 网络上行 → 网关排队 → 房间处理 → 广播 → 网络下行 → 客户端渲染

帧预算（33ms）
  └── 操作预算（120ms）
        └── 结算预算（2s）

时间尺度越大，越允许异步；
但每一层都必须有独立的上限和观测。

// file: internal/budget/budget.go
// tier: L1
// verify: go test ./internal/budget/
package budget

import (
	"fmt"
	"sort"
)

// Kind separates the three latency budgets a game server must never mix.
type Kind string

const (
	Frame      Kind = "frame"      // one simulation tick
	Operation  Kind = "operation"  // one player-visible action
	Settlement Kind = "settlement" // one match or season settlement
)

type Budget struct {
	Kind Kind
	P99  int64 // milliseconds
	Max  int64 // milliseconds
}

type Sample struct {
	Kind Kind
	MS   int64
}

type Violation struct {
	Kind  Kind
	MS    int64
	Limit int64
}

func (v Violation) String() string {
	if v.Limit < 0 {
		return fmt.Sprintf("%s=%dms has no configured budget", v.Kind, v.MS)
	}
	return fmt.Sprintf("%s=%dms exceeds max=%dms", v.Kind, v.MS, v.Limit)
}

// Check reports every sample that exceeds its kind's hard max.
func Check(budgets map[Kind]Budget, samples []Sample) []Violation {
	var out []Violation
	for _, s := range samples {
		b, ok := budgets[s.Kind]
		if !ok {
			out = append(out, Violation{Kind: s.Kind, MS: s.MS, Limit: -1})
			continue
		}
		if s.MS > b.Max {
			out = append(out, Violation{Kind: s.Kind, MS: s.MS, Limit: b.Max})
		}
	}
	return out
}

// Quantile returns the nearest-rank q-quantile (0 < q <= 1).
func Quantile(values []int64, q float64) int64 {
	if len(values) == 0 {
		return 0
	}
	if q <= 0 {
		q = 0.01
	}
	if q > 1 {
		q = 1
	}
	sorted := append([]int64(nil), values...)
	sort.Slice(sorted, func(i, j int) bool { return sorted[i] < sorted[j] })
	rank := int(q*float64(len(sorted)) + 0.999999)
	if rank < 1 {
		rank = 1
	}
	if rank > len(sorted) {
		rank = len(sorted)
	}
	return sorted[rank-1]
}

// Summary is the report a chapter or a load test should publish.
type Summary struct {
	Kind  Kind
	Count int
	P50   int64
	P99   int64
	Max   int64
}

func Summarize(kind Kind, samples []Sample) Summary {
	values := make([]int64, 0, len(samples))
	for _, s := range samples {
		if s.Kind == kind {
			values = append(values, s.MS)
		}
	}
	if len(values) == 0 {
		return Summary{Kind: kind}
	}
	max := values[0]
	for _, v := range values[1:] {
		if v > max {
			max = v
		}
	}
	return Summary{
		Kind:  kind,
		Count: len(values),
		P50:   Quantile(values, 0.50),
		P99:   Quantile(values, 0.99),
		Max:   max,
	}
}

// file: internal/budget/budget_test.go
// tier: L1
// verify: go test ./internal/budget/
package budget

import "testing"

func TestQuantileNearestRank(t *testing.T) {
	values := []int64{10, 20, 30, 40, 50, 60, 70, 80, 90, 100}
	cases := []struct {
		q    float64
		want int64
	}{
		{0.50, 50},
		{0.90, 90},
		{0.99, 100},
		{1.00, 100},
	}
	for _, c := range cases {
		if got := Quantile(values, c.q); got != c.want {
			t.Fatalf("Quantile(q=%.2f)=%d, want %d", c.q, got, c.want)
		}
	}
}

func TestCheckSeparatesBudgets(t *testing.T) {
	budgets := map[Kind]Budget{
		Frame:      {Kind: Frame, P99: 33, Max: 50},
		Operation:  {Kind: Operation, P99: 120, Max: 200},
		Settlement: {Kind: Settlement, P99: 1000, Max: 2000},
	}
	samples := []Sample{
		{Kind: Frame, MS: 28},
		{Kind: Frame, MS: 64},
		{Kind: Operation, MS: 180},
		{Kind: Operation, MS: 240},
		{Kind: Settlement, MS: 1800},
	}
	got := Check(budgets, samples)
	if len(got) != 2 {
		t.Fatalf("got %d violations, want 2: %v", len(got), got)
	}
	if got[0].Kind != Frame || got[0].MS != 64 {
		t.Fatalf("first violation=%v", got[0])
	}
	if got[1].Kind != Operation || got[1].MS != 240 {
		t.Fatalf("second violation=%v", got[1])
	}
}

func TestCheckRejectsUnknownKind(t *testing.T) {
	got := Check(map[Kind]Budget{}, []Sample{{Kind: "render", MS: 5}})
	if len(got) != 1 || got[0].Limit != -1 {
		t.Fatalf("got %v", got)
	}
}

func TestSummarize(t *testing.T) {
	samples := []Sample{
		{Kind: Frame, MS: 10}, {Kind: Frame, MS: 20}, {Kind: Frame, MS: 30},
		{Kind: Operation, MS: 999},
	}
	s := Summarize(Frame, samples)
	if s.Count != 3 || s.P50 != 20 || s.Max != 30 {
		t.Fatalf("got %+v", s)
	}
}

$ cd .local/checks/gsarch-lab
$ go test ./internal/budget/ -v
=== RUN   TestQuantileNearestRank
--- PASS: TestQuantileNearestRank (0.00s)
=== RUN   TestCheckSeparatesBudgets
--- PASS: TestCheckSeparatesBudgets (0.00s)
=== RUN   TestCheckRejectsUnknownKind
--- PASS: TestCheckRejectsUnknownKind (0.00s)
PASS
ok  	gsarchlab/internal/budget	0.5s

frame:      count=120000 p50=28ms p99=41ms max=180ms  violations=12
operation:  count= 60000 p50=72ms p99=138ms max=900ms violations=31
settlement: count=   500 p50=420ms p99=1800ms max=2600ms violations=3