《游戏服务端架构·品类、状态与拓扑》4.2 tick、帧预算与世界时钟

for {
    simulateOneTick()
    time.Sleep(33 * time.Millisecond)
}

elapsed := time.Since(last)
for i := 0; i < int(elapsed/33ms); i++ {
    simulateOneTick()
}

世界时间轴（固定 33ms 一格）
|----|----|----|----|----|----|
 t0   t1   t2   t3   t4   t5
           ^
     墙上时间到这里，应执行到 t2

// file: internal/tick/loop.go
// tier: L1
// verify: go test ./internal/tick/
package tick

import (
	"time"

	"gsarchlab/internal/budget"
)

const (
	// Frame30Hz and Frame60Hz match the frame budgets in chapter 1: a 30Hz
	// simulation gets 33ms per step, a 60Hz simulation gets 16ms.
	Frame30Hz = 33 * time.Millisecond
	Frame60Hz = 16 * time.Millisecond

	// MaxFrame33 and MaxFrame16 are the hard ceilings from the same budget
	// table, roughly 1.5x the step. A step above the ceiling is a violation,
	// not just a slow frame.
	MaxFrame33 = 50 * time.Millisecond
	MaxFrame16 = 25 * time.Millisecond
)

// Loop converts wall-clock time into a fixed number of simulation steps.
// Interval is the fixed step, MaxCatchUp bounds how many steps one Advance
// may execute, and MaxFrame is the per-step budget used for violation checks.
type Loop struct {
	Interval   time.Duration
	MaxCatchUp int
	MaxFrame   time.Duration

	last      time.Time
	tick      uint64
	dropped   uint64
	rollbacks uint64
	drift     time.Duration
	samples   []budget.Sample
}

func New(interval time.Duration, maxCatchUp int, maxFrame time.Duration) *Loop {
	if interval <= 0 {
		interval = Frame30Hz
	}
	if maxCatchUp < 1 {
		maxCatchUp = 1
	}
	if maxFrame <= 0 {
		maxFrame = 2 * interval
	}
	return &Loop{Interval: interval, MaxCatchUp: maxCatchUp, MaxFrame: maxFrame}
}

// Start anchors the loop at a wall-clock instant and resets counters.
func (l *Loop) Start(at time.Time) {
	l.last = at
	l.tick = 0
	l.dropped = 0
	l.rollbacks = 0
	l.drift = 0
	l.samples = nil
}

// Step reports the logical world tick, which never moves backwards.
func (l *Loop) Step() uint64 { return l.tick }

func (l *Loop) Dropped() uint64   { return l.dropped }
func (l *Loop) Rollbacks() uint64 { return l.rollbacks }

// CatchUp answers how many fixed steps an elapsed duration is worth, without
// mutating the loop and without exceeding MaxCatchUp.
func (l *Loop) CatchUp(elapsed time.Duration) int {
	if elapsed <= 0 {
		return 0
	}
	n := int(elapsed / l.Interval)
	if n > l.MaxCatchUp {
		n = l.MaxCatchUp
	}
	return n
}

// Advance moves the loop up to the given wall-clock instant. It returns the
// number of steps the caller should simulate and the number of steps that were
// discarded because the process fell too far behind.
//
// After a normal advance, last is the start of the next unexecuted step and
// Drift holds the sub-step remainder. A large gap still consumes every due
// boundary, so only the sub-step remainder survives as drift.
func (l *Loop) Advance(now time.Time) (executed, dropped int) {
	if l.last.IsZero() {
		l.last = now
		return 0, 0
	}
	elapsed := now.Sub(l.last)
	if elapsed < 0 {
		// A backwards clock must not run the world in reverse. Re-anchor and
		// count it, so the caller can alert instead of silently losing time.
		l.rollbacks++
		l.last = now
		l.drift = 0
		return 0, 0
	}

	due := int(elapsed / l.Interval)
	executed = due
	if due > l.MaxCatchUp {
		executed = l.MaxCatchUp
		dropped = due - l.MaxCatchUp
		l.dropped += uint64(dropped)
	}

	// Advance the wall-clock anchor by every due step, including discarded
	// ones. That keeps the sub-step remainder stable instead of letting a
	// backlog permanently shift the loop's phase.
	l.last = l.last.Add(time.Duration(due) * l.Interval)
	l.tick += uint64(executed)
	l.drift = now.Sub(l.last)
	return executed, dropped
}

// Drift is the distance from the last completed step boundary to now. It is
// always in [0, Interval) after Advance, and it is what the next Advance will
// carry instead of sleeping a full interval and drifting further.
func (l *Loop) Drift(now time.Time) time.Duration {
	d := now.Sub(l.last)
	if d < 0 {
		return 0
	}
	return d
}

// RecordFrame feeds one measured step duration into the chapter 1 budget
// checker. Timing lives here; thresholds live in internal/budget.
func (l *Loop) RecordFrame(d time.Duration) {
	l.samples = append(l.samples, budget.Sample{
		Kind: budget.Frame,
		MS:   d.Milliseconds(),
	})
}

// FrameViolations reports steps that exceeded MaxFrame using the same
// budget.Check contract as the rest of the book.
func (l *Loop) FrameViolations() []budget.Violation {
	limits := map[budget.Kind]budget.Budget{
		budget.Frame: {
			Kind: budget.Frame,
			P99:  l.Interval.Milliseconds(),
			Max:  l.MaxFrame.Milliseconds(),
		},
	}
	return budget.Check(limits, l.samples)
}

// file: internal/tick/loop_test.go
// tier: L1
// verify: go test ./internal/tick/
package tick

import (
	"testing"
	"time"
)

func TestAdvanceRunsFixedSteps(t *testing.T) {
	base := time.Unix(1_700_000_000, 0)
	l := New(Frame30Hz, 8, MaxFrame33)
	l.Start(base)

	executed, dropped := l.Advance(base.Add(100 * time.Millisecond))
	if executed != 3 || dropped != 0 {
		t.Fatalf("executed=%d dropped=%d, want 3/0", executed, dropped)
	}
	if l.Step() != 3 {
		t.Fatalf("tick=%d, want 3", l.Step())
	}
	if got := l.Drift(base.Add(100 * time.Millisecond)); got != 1*time.Millisecond {
		t.Fatalf("drift=%v, want 1ms", got)
	}
}

func TestSingleLargeDelayCatchesUp(t *testing.T) {
	base := time.Unix(1_700_000_000, 0)
	l := New(Frame30Hz, 10, MaxFrame33)
	l.Start(base)

	// A 300ms stall is nine steps: below the cap, so all of them run.
	executed, dropped := l.Advance(base.Add(300 * time.Millisecond))
	if executed != 9 || dropped != 0 {
		t.Fatalf("executed=%d dropped=%d, want 9/0", executed, dropped)
	}
	if l.Step() != 9 || l.Dropped() != 0 {
		t.Fatalf("tick=%d dropped=%d", l.Step(), l.Dropped())
	}
}

func TestAdvanceOverCapDropsSteps(t *testing.T) {
	base := time.Unix(1_700_000_000, 0)
	l := New(Frame30Hz, 5, MaxFrame33)
	l.Start(base)

	// 500ms is 15 steps at 33ms. The cap allows 5 and discards 10.
	executed, dropped := l.Advance(base.Add(500 * time.Millisecond))
	if executed != 5 || dropped != 10 {
		t.Fatalf("executed=%d dropped=%d, want 5/10", executed, dropped)
	}
	if l.Step() != 5 || l.Dropped() != 10 {
		t.Fatalf("tick=%d dropped=%d", l.Step(), l.Dropped())
	}
	// All 15 due boundaries are consumed, leaving the 5ms remainder.
	if got := l.Drift(base.Add(500 * time.Millisecond)); got != 5*time.Millisecond {
		t.Fatalf("drift=%v, want 5ms", got)
	}
}

func TestClockRollbackDoesNotRewind(t *testing.T) {
	base := time.Unix(1_700_000_000, 0)
	l := New(Frame30Hz, 8, MaxFrame33)
	l.Start(base.Add(200 * time.Millisecond))
	l.Advance(base.Add(266 * time.Millisecond)) // 2 steps

	before := l.Step()
	executed, dropped := l.Advance(base.Add(100 * time.Millisecond))
	if executed != 0 || dropped != 0 {
		t.Fatalf("executed=%d dropped=%d, want 0/0", executed, dropped)
	}
	if l.Step() != before {
		t.Fatalf("tick moved backwards: %d -> %d", before, l.Step())
	}
	if l.Rollbacks() != 1 {
		t.Fatalf("rollbacks=%d, want 1", l.Rollbacks())
	}
	// The loop re-anchors at the new time and can advance normally again.
	if executed, _ := l.Advance(base.Add(133 * time.Millisecond)); executed != 1 {
		t.Fatalf("after rollback executed=%d, want 1", executed)
	}
}

$ cd .local/checks/gsarch-lab
$ gofmt -l internal/tick
$ go vet ./internal/tick
$ go test ./internal/tick/ -v -count=1
=== RUN   TestAdvanceRunsFixedSteps
--- PASS: TestAdvanceRunsFixedSteps (0.00s)
=== RUN   TestSingleLargeDelayCatchesUp
--- PASS: TestSingleLargeDelayCatchesUp (0.00s)
=== RUN   TestAdvanceOverCapDropsSteps
--- PASS: TestAdvanceOverCapDropsSteps (0.00s)
=== RUN   TestClockRollbackDoesNotRewind
--- PASS: TestClockRollbackDoesNotRewind (0.00s)
=== RUN   TestDriftIsCarriedAcrossAdvance
--- PASS: TestDriftIsCarriedAcrossAdvance (0.00s)
=== RUN   TestFrameViolationsUseBudgetPackage
--- PASS: TestFrameViolationsUseBudgetPackage (0.00s)
PASS
ok  	gsarchlab/internal/tick	0.267s