Slow motion: 24 causes and who fixes them

Also called: world slows down, everything sluggish

Everything moves slowly. Skill casts and monster movement look stretched out. Depending on the server design, speed can stay normal while it shows up as stutter or teleporting.

Everyone in the same area slows down together, usually where lots of players have gathered.

The server can’t finish its ticks on time. The network is fine, so ping measured outside the game stays the same; in-game ping can rise slightly if it includes time waiting for server processing. Check for player surges, AOI calculation, broadcast, and memory shortage.

Causes of this symptom

L1 Client game process

Fixed-timestep catch-up spiral: After one stall, the game runs its backlog of calculations all at once, and that extra work puts it behind again. (Game team (Client development))

L5 Data center network equipment

Load balancer skew and misjudged health checks: Connections pile onto one server, or players keep getting sent to a server that’s already dead. (Infra team (Network infrastructure))

L7 Server OS (kernel)

Too many threads and context switching: Running far more threads than there are cores makes the OS spend CPU just switching between them. (Game team (Server development))
Container CPU throttling (CFS quota): With a CPU limit on a container, the moment it uses up its quota within a set period (usually 100 ms), it is forced to stop for the rest of that period (throttling). (Infra team (Server infrastructure))
Latency spikes from server power management (C-states, frequency scaling): Idle CPU cores drop into deep power-saving states (C-states) and lower their frequency to save power. Waking up and raising the frequency when a packet or timer arrives takes time, which adds delay to handling small packets. (Infra team (Server infrastructure))
Scheduled jobs: Log compression, backups, and security scans that run at the same time every day take up CPU and disk. (Infra team (Server infrastructure))
Performance changes after OS, kernel, driver, or firmware updates: The game code hasn’t changed, but the server has been slower since an OS, kernel, driver, or firmware update. Updates can change defaults, the scheduler, CPU vulnerability mitigations, and driver behavior. (Infra team (Server infrastructure))

L8 Sockets and protocols

Blocking sends caused by slow clients: When one player on a slow connection has a full send buffer and the server sends in blocking mode (a send call that doesn’t return until the buffer has room), the server thread waits on that one player. (Game team (Server development))
Blocking I/O design: In a design where a thread can’t do anything else while it waits on one socket, everything slows down as the player count grows. (Game team (Server development))

L9 Server game process

Tick overrun: When one tick has more work than its budget, the server’s tick interval stretches, and the whole area slows down or stutters. (Game team (Server development))
AOI calculation blowup (N²): If you compare everyone against everyone to work out who can see whom, 10 times the players means 100 times the computation. (Game team (Server development))
Single-threaded zone overload (hotspot): When each area runs on a single thread and players crowd into one place, only that one core hits 100%. (Game team (Server development))
Pathfinding storm: When hundreds of monsters chase players and compute paths at the same time, it takes a lot of CPU. (Game team (Server development))
Combat concentrated on one target (world boss): When hundreds of players hit one boss at the same time, the computation for that single boss piles up in one place, and hit information goes out to everyone watching. (Game team (Server development))
Entity buildup (items and summons never cleaned up): When ground items that should have disappeared, summons, and finished timers pile up without being cleaned up, every tick has more work to do the longer the server stays up. (Game team (Server development))

L10 Memory

Memory leak: Memory that is never freed piles up little by little and, days later, leads to GC storms, swapping, or the process getting killed. (Game team (Server development))
GC thrashing (too little heap headroom): When live data gets close to the heap limit, each GC reclaims almost nothing, so GC runs over and over without a break. (Game team (Server development))
Swap: When memory runs short and the OS moves part of it out to disk, every access to that memory waits on a disk more than 1,000 times slower. (Infra team (Server infrastructure))
Cache miss: When data is scattered all over memory, the CPU has to go all the way out to slow RAM and wait every time. (Game team (Server development))
Memory fragmentation: When repeated allocation and freeing chops free space into small pieces, the process holds far more memory than it actually uses. (Game team (Server development))
Remote NUMA memory: On a server with two CPUs, using memory attached to the other CPU slows access down. (Infra team (Server infrastructure))

L11 Disk

Cloud disk out of burst credits: Some cloud disks and small server sizes have burst credits that let them run faster than baseline for a while, so when a busy period drags on and the credits run out, speed drops suddenly. (Infra team (Server infrastructure))

L13 Server architecture and operations

Autoscaling delay: When players flood in, servers are added automatically, but getting them ready takes several minutes, and the existing servers are overloaded in the meantime. (Infra team (Server infrastructure))
Too many macros and bots: Bots send requests far more often than people do and eat into server capacity. (Game team (Server development))

View the illustrated symptom guide