Round-Robin Scheduling

Round-robin scheduling is a preemptive scheduling method that gives runnable tasks at the same priority a fixed time quantum in cyclic order. When a task exhausts its quantum, the scheduler places it at the back of the ready queue and runs the next eligible peer.

The method is attractive because it gives simple fairness among CPU-ready peers. It is not automatically a hard real-time guarantee. The response time depends on the quantum, the number of runnable peers, context-switch overhead, blocking, priority classes, interrupt load and whether the workload is CPU-bound or frequently sleeping.

Scheduling Rule

Let the time quantum be:

and let the number of runnable tasks at the same priority be:

Ignoring overhead, a task that just missed its turn may wait approximately:

before it receives another quantum. This is a same-priority wait bound, not a complete response-time analysis.

Quantum Tradeoff

A smaller quantum can reduce interactive wait, but it increases context-switch rate. A larger quantum improves cache locality and batching efficiency, but it can make peers wait too long.

If each switch costs:

then one round through the queue is approximately:

and the direct useful CPU fraction within that cycle is:

This expression does not include cache warm-up or memory-locality loss, so it is optimistic for workloads with large working sets.

Worked Response Screen

Suppose five same-priority CPU-bound tasks share a processor:

The scheduler uses:

and the measured context-switch cost is:

The worst same-priority wait after a task just misses its turn is:

If the interaction target is:

then the wait margin is:

The design passes this narrow screen only if the task can run immediately after the wait and no additional blocking, interrupt storm, cache warm-up or priority interference consumes the margin.

Overhead Screen

For the same example, one full rotation lasts:

The direct CPU efficiency is:

or about:

The efficiency looks good, but the margin is still only 0.68 ms. Round-robin design must therefore check both CPU overhead and user-visible or deadline-visible wait.

Fairness Limits

Round-robin is fair only within the queue it actually rotates. A lower-priority task can still starve if higher-priority work keeps arriving. A task that blocks on a lock may lose time outside the ready queue. A task with a large cache footprint may suffer more from every rotation than a small task, even though both receive equal quanta.

For hard real-time tasks, fixed-priority response-time analysis or EDF-style demand analysis may be more appropriate than treating equal turns as sufficient evidence. Round-robin can be useful for best-effort work around a real-time core, but the scheduling boundary must be explicit.

Validation Evidence

Useful evidence includes the configured quantum, scheduler class, priority level, number of runnable peers, context-switch duration, context-switch rate, ready-queue length, CPU affinity, migration count, interrupt load, lock wait time, p95 and p99 wakeup latency, maximum observed ready-to-running delay and traces around overload.

The validation test should force worst phasing: release an interactive or latency-sensitive task just after it lost its turn, keep the expected number of same-priority peers runnable, and measure whether the actual ready-to-running delay stays below the target.

Design Levers

Engineering levers include reducing the quantum, reducing runnable peer count, separating latency-sensitive work into a different priority or scheduler class, limiting worker admission, pinning critical tasks, reducing context-switch cost, removing lock convoys and avoiding background work at the same priority.

The cheapest lever is not always correct. A very small quantum can create overhead and cache churn. A very large quantum can make interactive work visibly sluggish. A useful setting is the one that preserves wait margin while keeping switch overhead and locality loss inside budget.

Relationship To Neighbor Terms

Preemption latency includes scheduler decision time and same-priority queueing, but it is broader than round-robin. Context switch overhead is the cost paid when the round-robin policy changes tasks. Scheduler tick can define the quantum resolution in simple kernels. Task starvation is the failure mode when a runnable task does not receive service within an acceptable bound.