Scheduling Criteria

Scheduling criteria are the measurable properties used to judge how well a CPU scheduling algorithm performs on a set of processes. The standard criteria are CPU utilization and throughput, where higher is better, and turnaround time, waiting time and response time, where lower is better, and they let algorithms such as FCFS, SJF and Round Robin be compared.

4 min read

When comparing scheduling algorithms, or evaluating whether a given algorithm did a good job on a specific set of processes, there are several standard, measurable criteria used. Understanding these is what lets the comparisons between FCFS, SJF, Round Robin, and every other algorithm actually mean something concrete.

The standard criteria

CPU utilization. The percentage of time the CPU is actually doing useful work, as opposed to sitting idle. Higher is better; a well-utilized system keeps the CPU busy as close to 100% as possible.

Throughput. The number of processes completed per unit of time. Higher is better, more work finished in the same amount of time.

Turnaround time. The total time from when a process arrives until it completes, including all waiting, execution, and I/O time. Lower is better.

Waiting time. The total time a process spends sitting in the ready queue, waiting for the CPU, not counting time spent actually executing or doing I/O. Lower is better, this is often the single most-optimized metric in scheduling algorithm comparisons.

Response time. For interactive systems specifically, the time from when a request is submitted until the system produces its first response (not necessarily full completion). Lower is better, and this matters distinctly from turnaround time for anything a human is waiting on directly.

Why these criteria can conflict

Optimizing hard for one criterion often costs another. SJF minimizes average waiting time, but a long process can wait indefinitely (poor for that specific process's own turnaround time and fairness) while short jobs keep jumping ahead. Round Robin gives excellent response time for interactive use, since every process gets the CPU at regular intervals, but its frequent context switching hurts raw CPU utilization and throughput compared to a scheme that switches less often.

A worked example

Two processes, P1 (burst time 20) and P2 (burst time 2), both arriving at time 0.

Under FCFS (P1 first): P1 runs 0 to 20, P2 runs 20 to 22. P1's waiting time is 0, P2's waiting time is 20. Average waiting time: 10. P2's response time is a poor 20 (it had to wait the entire time P1 ran before getting any CPU at all), even though its own work only takes 2.

Under SJF (shortest first): P2 runs first (0 to 2), then P1 (2 to 22). P2's waiting time is 0, P1's waiting time is 2. Average waiting time: 1, dramatically better than FCFS's 10. P2's response time is now excellent (0), while P1's average metrics stayed reasonable.

This one example is exactly why SJF is described as optimal for average waiting time, and it's a concrete illustration of how the same two processes produce wildly different scheduling-criteria outcomes depending purely on which algorithm decides the order.

Where this matters in real systems

Real operating system schedulers are tuned with these exact metrics in mind, but the tuning differs by what the system is for. A batch-processing server optimizes hard for throughput and CPU utilization. A desktop OS optimizes hard for response time, since a human is sitting there noticing every millisecond of input lag. A real-time embedded system cares about a completely different criterion not listed above: meeting hard deadlines, where "how long on average" matters far less than "did every single task finish within its required deadline, every time."

What interviewers actually ask about scheduling criteria

  • "Name the standard scheduling criteria." CPU utilization, throughput, turnaround time, waiting time, and response time.
  • "What's the difference between turnaround time and waiting time?" Turnaround time is total time from arrival to completion, including execution and I/O; waiting time is only the portion of that spent sitting in the ready queue, not executing or doing I/O.
  • "What's the difference between turnaround time and response time?" Turnaround time measures until full completion; response time measures until the first response or output, which matters distinctly for interactive systems where a user doesn't necessarily need the whole job done immediately, just some initial feedback.
  • "Why can't a scheduler optimize all these criteria simultaneously?" Because they genuinely conflict in practice, for example minimizing average waiting time (SJF) can come at the cost of fairness and worst-case turnaround time for long processes, while excellent response time (Round Robin) costs some raw throughput due to more frequent context switching.

Key takeaways

  • CPU utilization, throughput, turnaround time, waiting time, and response time are the standard scheduling evaluation criteria.
  • Lower is better for turnaround/waiting/response time; higher is better for utilization/throughput.
  • These criteria genuinely conflict, optimizing one often costs another.
  • Real systems choose which criteria to prioritize based on their actual purpose: batch throughput, interactive responsiveness, or hard real-time deadlines.
All 205 OS interview questions

Browse all Operating Systems topics

Log in to save which topics you've read across every subject.

Frequently asked questions

Name the standard scheduling criteria.

CPU utilization, throughput, turnaround time, waiting time, and response time.

What's the difference between turnaround time and waiting time?

Turnaround time is total time from arrival to completion, including execution and I/O; waiting time is only the portion of that spent sitting in the ready queue, not executing or doing I/O.

What's the difference between turnaround time and response time?

Turnaround time measures until full completion; response time measures until the first response or output, which matters distinctly for interactive systems where a user doesn't necessarily need the whole job done immediately, just some initial feedback.

Why can't a scheduler optimize all these criteria simultaneously?

Because they genuinely conflict in practice, for example minimizing average waiting time (SJF) can come at the cost of fairness and worst-case turnaround time for long processes, while excellent response time (Round Robin) costs some raw throughput due to more frequent context switching.