《MMO 服务器开发》5.3 丢包与弱网模拟实测

// file: internal/kcp/sim_test.go
// tier: B
// verify: go test -run TestLossyBenchmark ./internal/kcp/
package kcp

import (
	"math/rand"
	"testing"
)

// simLink 是 5.3 用的确定性弱网链路：固定种子同时决定丢包与抖动，
// 因此同一个种子在任何机器上都会跑出同一组数字。
type simLink struct {
	now      uint32
	rng      *rand.Rand
	loss     float64
	rtt      uint32
	jitter   uint32
	queue    []simPkt
	allPkts  int
	dataPkts int
}

type simPkt struct {
	at   uint32
	data []byte
	dst  *KCP
}

// send 是底层发包口：先计数（含将要丢弃的），再按丢包率决定是否真的投递。
func (l *simLink) send(buf []byte, dst *KCP) {
	l.allPkts++
	if len(buf) >= headerSize && buf[4] == cmdPush {
		l.dataPkts++
	}
	if l.loss > 0 && l.rng.Float64() < l.loss {
		return
	}
	lat := l.rtt / 2
	if l.jitter > 0 {
		lat += uint32(l.rng.Intn(int(l.jitter) + 1))
	}
	l.queue = append(l.queue, simPkt{at: l.now + lat, data: append([]byte(nil), buf...), dst: dst})
}

func (l *simLink) deliver(t uint32) {
	for i := 0; i < len(l.queue); {
		if l.queue[i].at <= t {
			p := l.queue[i]
			l.queue = append(l.queue[:i], l.queue[i+1:]...)
			p.dst.Input(p.data)
		} else {
			i++
		}
	}
}

// runKCPSim 在弱网下把 n 条消息按 interval 毫秒的节拍从 A 发到 B，
// 返回每条消息的端到端延迟（毫秒）与累计数据包发送数。
func runKCPSim(seed int64, loss float64, rtt, jitter uint32, n, interval int) ([]float64, int) {
	l := &simLink{rng: rand.New(rand.NewSource(seed)), loss: loss, rtt: rtt, jitter: jitter}
	var a, b *KCP
	a = NewKCP(1, func(buf []byte) { l.send(buf, b) })
	b = NewKCP(1, func(buf []byte) { l.send(buf, a) })
	a.SetWindow(64, 128)
	b.SetWindow(64, 128)

	payload := []byte("dawn-realm: 玩家移动状态包 0123456789")
	delays := make([]float64, 0, n)
	sendAt := make([]float64, n)
	sent, got := 0, 0
	var buf [256]byte
	total := uint32(n*interval + 5000)
	for t := uint32(0); t <= total; t++ {
		if sent < n && int(t) == sent*interval {
			a.Send(payload)
			sendAt[sent] = float64(t)
			sent++
		}
		l.now = t
		a.Update(t)
		b.Update(t)
		l.deliver(t)
		for got < n {
			r := b.Recv(buf[:])
			if r < 0 {
				break
			}
			delays = append(delays, float64(t)-sendAt[got])
			got++
		}
	}
	return delays, l.dataPkts
}

// TestLossyBenchmark 在固定种子的弱网下测 KCP 的消息延迟与冗余发送率，
// 并与 5.1 的单流 TCP 式基线对比。B 层，产出数字，软告警。
func TestLossyBenchmark(t *testing.T) {
	const (
		n        = 300
		interval = 33 // 约 30Hz
		rtt      = 60
		jitter   = 10
		seed     = 20261006
	)
	cfg := SimConfig{Seed: seed, RTTMs: rtt, JitterMs: jitter, RTOFactor: 2, Count: n, IntervalMs: interval}
	for _, loss := range []float64{0, 0.01, 0.05, 0.20} {
		delays, dataPkts := runKCPSim(seed, loss, rtt, jitter, n, interval)
		ks := Summarize(delays)
		cfg.LossRate = loss
		ts := Summarize(Simulate(cfg, 1))
		redundancy := float64(dataPkts) / float64(n)
		t.Logf("loss=%4.0f%% | KCP P50=%6.1f P99=%7.1f max=%8.1f | TCP式 P50=%6.1f P99=%7.1f | 到达 %d/%d 冗余=%.2fx",
			loss*100, ks.P50, ks.P99, ks.Max, ts.P50, ts.P99, len(delays), n, redundancy)
	}
}

// snippet: internal/kcp/hol.go 的基线模型
type SimConfig struct {
	Seed       int64   // 固定随机种子
	LossRate   float64 // 丢包率，0~1
	RTTMs      float64 // 往返时延（毫秒）
	JitterMs   float64 // 单向抖动上限（毫秒）
	RTOFactor  float64 // 重传超时 = RTOFactor × RTT
	Count      int     // 消息条数
	IntervalMs float64 // 相邻消息的发送间隔（毫秒）
}

// Simulate 用同一条消息流跑一次虚拟信道，返回每条消息的端到端延迟。
// streams == 1 时所有消息共享一条有序流，即 TCP 语义。
func Simulate(cfg SimConfig, streams int) []float64 {
	rng := rand.New(rand.NewSource(cfg.Seed))
	delays := make([]float64, cfg.Count)
	last := make([]float64, streams)
	for i := range last {
		last[i] = math.Inf(-1)
	}
	for i := 0; i < cfg.Count; i++ {
		send := float64(i) * cfg.IntervalMs
		a := cfg.arrival(rng, send)
		s := i % streams
		// 关键的一行：交付时刻不能早于本通道上一条消息的交付时刻。
		d := math.Max(a, last[s])
		last[s] = d
		delays[i] = d - send
	}
	return delays
}

$ go test -run TestLossyBenchmark -v ./internal/kcp/
loss=   0% | KCP P50=  40.0 P99=   49.0 max=    49.0 | TCP式 P50=  34.7 P99=   39.9 | 到达 300/300 冗余=1.00x
loss=   1% | KCP P50=  40.0 P99=  141.0 max=   187.0 | TCP式 P50=  35.6 P99=  154.0 | 到达 300/300 冗余=1.05x
loss=   5% | KCP P50=  40.0 P99=  155.0 max=   188.0 | TCP式 P50=  36.8 P99=  239.6 | 到达 300/300 冗余=1.14x
loss=  20% | KCP P50=  55.0 P99=  357.0 max=   456.0 | TCP式 P50=  86.8 P99=  359.6 | 到达 300/300 冗余=1.49x