《游戏服务端架构·规模化、全球化与成本》9.3 成本与体验的取舍

score = saving × reversibility / (1 + experience)

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

import (
	"errors"
	"sort"
)

// Lever is one cost-reduction measure with the two numbers that decide
// whether it is allowed: how much it hurts and how easily it is undone.
type Lever struct {
	ID            string
	Experience    float64 // 0..10, expected player-visible impact
	SavingPct     float64 // 0..1, share of the addressed scope saved
	Reversibility float64 // 0..1, 1 means a config flag flips it back
	ScopePct      float64 // 0..1, share of the total bill the lever addresses
}

// Policy is the review gate. A lever must pass every threshold on its own.
type Policy struct {
	MaxExperience     float64
	MinSavingPct      float64
	MinReversibility  float64
	MaxCombinedImpact float64 // sum of admitted experience scores
}

// Decision records one lever after the gate, including the reason it lost.
type Decision struct {
	Lever    Lever
	Score    float64
	Admitted bool
	Reason   string
}

// Validate rejects values outside the documented ranges. A bad number in a
// cost review is worse than a missing one because it silently wins.
func Validate(l Lever) error {
	switch {
	case l.Experience < 0 || l.Experience > 10:
		return errors.New("costexperience: experience must be within [0,10]")
	case l.SavingPct < 0 || l.SavingPct > 1:
		return errors.New("costexperience: saving must be within [0,1]")
	case l.Reversibility < 0 || l.Reversibility > 1:
		return errors.New("costexperience: reversibility must be within [0,1]")
	case l.ScopePct < 0 || l.ScopePct > 1:
		return errors.New("costexperience: scope must be within [0,1]")
	}
	return nil
}

// Score rewards savings and reversibility, and discounts experience damage.
// The denominator keeps a zero-impact lever finite and a ten-impact lever
// from being selected by a large saving alone.
func Score(l Lever) float64 {
	if err := Validate(l); err != nil {
		return 0
	}
	return l.SavingPct * l.Reversibility / (1 + l.Experience)
}

// Evaluate applies the per-lever thresholds and returns a deterministic,
// score-descending list. Rejected levers stay in the result so the review
// can show what was considered and why it lost.
func Evaluate(levers []Lever, p Policy) []Decision {
	out := make([]Decision, 0, len(levers))
	for _, l := range levers {
		d := Decision{Lever: l, Score: Score(l)}
		switch {
		case Validate(l) != nil:
			d.Reason = "invalid range"
		case l.Experience > p.MaxExperience:
			d.Reason = "experience impact above policy"
		case l.SavingPct < p.MinSavingPct:
			d.Reason = "saving below policy"
		case l.Reversibility < p.MinReversibility:
			d.Reason = "not reversible enough"
		default:
			d.Admitted = true
		}
		out = append(out, d)
	}
	sort.SliceStable(out, func(i, j int) bool {
		if out[i].Admitted != out[j].Admitted {
			return out[i].Admitted
		}
		if out[i].Score != out[j].Score {
			return out[i].Score > out[j].Score
		}
		return out[i].Lever.ID < out[j].Lever.ID
	})
	return out
}

// Selected returns only admitted levers, preserving score order.
func Selected(decisions []Decision) []Lever {
	var out []Lever
	for _, d := range decisions {
		if d.Admitted {
			out = append(out, d.Lever)
		}
	}
	return out
}

// Estimate is the combined result of admitted levers. Savings are additive
// against disjoint scopes and capped at the baseline; experience is summed
// because several small degradations can add up to one bad session.
type Estimate struct {
	BaselineMicros int64
	AfterMicros    int64
	SavingMicros   int64
	ExperienceSum  float64
	WithinBudget   bool
}

// Combine estimates the bill after all admitted levers. A zero
// MaxCombinedImpact means the combined gate is not configured.
func Combine(baselineMicros int64, levers []Lever, p Policy) Estimate {
	if baselineMicros < 0 {
		baselineMicros = 0
	}
	est := Estimate{BaselineMicros: baselineMicros, AfterMicros: baselineMicros}
	for _, d := range Evaluate(levers, p) {
		if !d.Admitted {
			continue
		}
		saving := int64(float64(baselineMicros) * d.Lever.ScopePct * d.Lever.SavingPct)
		est.SavingMicros += saving
		est.ExperienceSum += d.Lever.Experience
	}
	if est.SavingMicros > est.BaselineMicros {
		est.SavingMicros = est.BaselineMicros
	}
	est.AfterMicros = est.BaselineMicros - est.SavingMicros
	est.WithinBudget = p.MaxCombinedImpact <= 0 || est.ExperienceSum <= p.MaxCombinedImpact
	return est
}

cd .local/checks/gsarch-lab
go test -count=1 ./internal/costexperience/
ok  gsarchlab/internal/costexperience