This is a queueing-theory sibling of the 3D tier-ladder simulator: instead of sampling a synthetic per-tick cost, a real single-server queue is simulated. A new frame request "arrives" every budget ms — the vsync cadence — and waits in line for the one render server, which takes tierCost·stress ms to service it at the current enhancement tier. The measured completion time of every serviced frame feeds the same EMA + hysteresis controller as the 3D version:
arrival: every budget = 1000/targetFPS ms, enqueue a frame
service: duration = tierCost[tier]·stress·throttle + noise
raw = duration (measured, not assumed)
ema = alpha·raw + (1-alpha)·ema (alpha = 0.2)
If ema > budget: overCount++, underCount = 0
Else if ema < 0.7·budget: underCount++, overCount = 0
Else: (dead zone — no change)
If overCount >= window: tier = max(tier-1, 0); overCount = 0
If underCount >= 2·window: tier = min(tier+1, 4); underCount = 0
Because arrivals and service are now genuinely discrete events rather than a fixed-rate sampler, a real backlog can form: if the server is slower than the arrival rate (ρ = λ·E[service] ≥ 1), frames pile up in the queue exactly like dropped/janky frames on a real device, and old ones are discarded once the queue overflows (a frame drop). Little's Law (L̄ = λ·W̄ — the average number of frames in the system equals the arrival rate times the average time each frame spends in it) is measured live from the running simulation and displayed for verification.
- Device stress slider — multiplies every service time, modelling background CPU contention or a thermally-throttled core.
- Target frame budget — sets both the arrival rate (vsync cadence) and the threshold the controller compares the EMA against.
- Hysteresis window — downgrading needs window consecutive over-budget completions; upgrading needs 2×window comfortably-under-budget ones, so quality drops fast and recovers cautiously.
- Throttle spike — injects a ~2.2× service-time multiplier for 2 seconds, like the OS momentarily stealing the core for a GC pause.
Real-world relevance: this is the same math behind Android's Choreographer frame-pacing and any renderer that measures actual submit-to-present latency (not an assumed cost) before deciding to shed visual quality — and Little's Law is the standard sanity check used to validate a queueing model against its own measured traces.