Three processes P1 (24ms burst), P2 (3ms burst), and P3 (3ms burst) arrive simultaneously. With a quantum of 4ms, when does P2 finish?
AAt 3ms — P2 runs first and completes immediately
BAt 7ms — P1 runs 4ms, then P2 runs its 3ms and finishes
CAt 10ms — all three processes share the CPU equally before any finishes
DAt 4ms — P2 gets a full quantum before being preempted
The ready queue order at time 0 is P1, P2, P3. P1 runs for 4ms (its full quantum), then yields. P2 runs for 3ms and finishes — it needed less than a full quantum, so it completes at 4 + 3 = 7ms. Under FCFS, P2 would have waited 24ms before even starting. This illustrates Round-Robin's core advantage: short jobs get CPU time quickly rather than waiting behind long-running processes.
Question 2 Multiple Choice
A system administrator reduces the Round-Robin time quantum from 50ms to 1ms. Which of the following most accurately describes the result?
AThroughput and response time both improve because processes get CPU time more frequently
BResponse time improves but throughput may decrease because the system spends more time on context switching overhead
CPerformance is unchanged because every process still gets the same total CPU time
DThe system behaves more like FCFS because context switches become rare
With a 1ms quantum, every process gets a turn very quickly — response time (time to first CPU access) drops dramatically. But each context switch incurs overhead: saving and restoring registers, cache flushing, scheduler overhead. With a 1ms quantum, the system might spend half its CPU time on context switching rather than actual computation, reducing throughput. The quantum must be large enough to amortize context-switch cost while small enough to maintain responsiveness — typically 10–100ms in practice.
Question 3 True / False
Round-Robin scheduling guarantees that every process in the ready queue will eventually receive CPU time, regardless of how long any individual process runs.
TTrue
FFalse
Answer: True
This is Round-Robin's defining guarantee and why it underpins time-sharing systems. Because every process is preempted after at most one quantum and moved to the back of the ready queue, no process can monopolize the CPU indefinitely. Even a process with a 10-second burst will only hold the CPU for one quantum at a time before other processes get their turn. This prevents the starvation that can occur in priority scheduling and the convoy effect in FCFS.
Question 4 True / False
Reducing the time quantum in Round-Robin generally improves overall system performance.
TTrue
FFalse
Answer: False
This is false and is the central design tension in Round-Robin. A smaller quantum improves response time (processes wait less for their first CPU turn) but increases the proportion of CPU time spent on context switching. If the quantum falls below the context-switch overhead, the system spends more time switching than computing — throughput collapses. Performance is not monotonically improved by reducing the quantum; there is a sweet spot that balances responsiveness against overhead.
Question 5 Short Answer
Explain why a very large time quantum in Round-Robin degrades into FCFS-like behavior, and why this is problematic for interactive systems.
Think about your answer, then reveal below.
Model answer: When the quantum is very large, most processes complete their entire CPU burst within a single quantum before being preempted. This means processes effectively run to completion without interruption — exactly what FCFS does. Short jobs that arrive after a long-running process must wait the full burst time of the long process before getting any CPU time. Interactive systems require short response times: a user clicking a button expects a near-instant reaction. Under FCFS-like behavior, if a long compilation job is running, the user's UI event might wait seconds for its first CPU slice. Round-Robin's value comes precisely from its preemption of long jobs at regular intervals.
The ideal quantum is large enough that most short jobs complete in one quantum (avoiding unnecessary preemptions) but small enough that the wait between consecutive quanta is imperceptible to users. The classic rule of thumb is that about 80% of CPU bursts should be shorter than the quantum — this ensures that most jobs complete quickly without excessive context switching while the minority of long-running jobs are preempted fairly.