CPU Scheduling
CPU Scheduler
Short-term scheduler selects from among the
processes in ready queue, and allocates the CPU to one
of them
Queue may be ordered in various ways
CPU scheduling decisions may take place when a
process:
1. Switches from running to waiting state
2. Switches from running to ready state
3. Switches from waiting to ready
4. Terminates
Scheduling can be non-preemptive/ preemptive
Nonpreemptive ✴Once a process is in
the running state, it will continue to
execute until it terminates OR it
blocks itself for I/O or some OS service
Preemptive ✴ Currently running process
may be interrupted and moved to the
Ready state by the operating system
when
• a new process arrives
• interrupt occurs
Dispatcher
Dispatcher module gives control of the CPU to
the process selected by the short-term
scheduler; this involves:
switching context
switching to user mode
jumping to the proper location in the user
program to restart that program
Dispatch latency – time it takes for the
dispatcher to stop one process and start
another running
short-term scheduling
The main objective of short-term scheduling is
to allocate CPU time to processes
Executes most frequently
Invoked when an event occurs that may lead to
the blocking of the current process or that may
provide an opportunity to preempt a currently
running process in favour of another
Clock interrupts
I/O interrupts
Operating system calls
Scheduling Objectives
The scheduling function should:
Share time fairly among
processes
Prevent starvation of processes
Have low overhead
Prioritize processes when
necessary
Scheduling Criteria
CPU utilization – keep the CPU as busy as
possible
Throughput – number of processes that
complete their execution per time unit
Turnaround time – amount of time to execute a
particular process (Completion Time – Arrival
Time)
Waiting time – amount of time a process has
been waiting in the ready queue (Turnaround
time-Burst time)
Response time – amount of time it takes from
when a request was submitted until the first
response is produced, not output (First
response time-arrival time)
Scheduling Algorithm Optimization Criteria
Max CPU utilization
Max throughput
Min turnaround time
Min waiting time
Min response time
First- Come, First-Served (FCFS) Scheduling
Process Burst Time
P1 24
P2 3
P3 3
Suppose that the processes arrive in the order:
P1 , P2 , P3
The Gantt Chart for the schedule is:
P1 P2 P3
0 24 27 30
Waiting time for P = 0; P = 24; P = 27
1 2 3
Average waiting time: (0 + 24 + 27)/3 = 17
FCFS Scheduling (Cont.)
Suppose that the processes arrive in the
order:
P2 , P3 , P1
The
P 2 Gantt
P3 chart for the schedule
P1 is:
0 3 6 30
Waiting time for P1 = 6; P2 = 0; P3 = 3
Average waiting time: (6 + 0 + 3)/3 = 3
Much better than previous case
Convoy effect - short process behind long process
Shortest-Job-First (SJF) Scheduling
Associate with each process the length
of its next CPU burst
Use these lengths to schedule the
process with the shortest time
SJF is optimal – gives minimum average
waiting time for a given set of
processes
The difficulty is knowing the length of
the next CPU request
Example of SJF
ProcessArriva l Time Burst Time
P1 0.0 6
P2 2.0 8
P3 4.0 7
P4 5.0 3
SJF scheduling chart
P4 P1 P3 P2
0 3 9 16 24
Average waiting time = (3 + 16 + 9 + 0) / 4 = 7
Preemptive version called shortest-remaining-time-first
Example of Shortest-remaining-time-first
Now we add the concepts of varying arrival times and
preemption to the analysis
ProcessA arri Arrival TimeT Burst Time
P1 0 8
P2 1 4
P3 2 9
P4 3 5
Preemptive SJF Gantt Chart
P1 P2 P4 P1 P3
0 1 5 10 17 26
Average waiting time = [(10-1)+(1-1)+(17-2)+5-3)]/4 = 26/4 = 6.5
msec
Priority Scheduling
A priority number is associated with each process
The CPU is allocated to the process with the highest
priority (smallest integer highest priority)
Preemptive
Nonpreemptive
SJF is priority scheduling where priority is the inverse
of predicted next CPU burst time
Problem Starvation – low priority processes may
never execute
Solution Aging – as time progresses increase the
priority of the process
Round Robin (RR)
Each process gets a small unit of CPU time
(time quantum q), usually 10-100 milliseconds.
After this time has elapsed, the process is
preempted and added to the end of the ready
queue.
Timer interrupts every quantum to schedule
next process
Performance
q large FIFO
q small q must be large with respect to
context switch, otherwise overhead is too
high
Example of RR with Time Quantum = 4
Process Burst Time
P1 24
P2 3
P3 3
The Gantt chart is:
P1 P2 P3 P1 P1 P1 P1 P1
0 4 7 10 14 18 22 26 30
Typically, higher average turnaround than SJF, but better
response
Multilevel Queue
Ready queue is partitioned into separate queues, eg:
foreground (interactive)
background (batch)
Process permanently in a given queue
Each queue has its own scheduling algorithm:
foreground – RR
background – FCFS
Scheduling must be done between the queues:
Fixed priority scheduling; (i.e., serve all from foreground then
from background). Possibility of starvation.
Time slice – each queue gets a certain amount of CPU time
which it can schedule amongst its processes; i.e., 80% to
foreground in RR 20% to background in FCFS
Multilevel Queue Scheduling
Multilevel Feedback Queue
A process can move between the various queues;
aging can be implemented this way
Multilevel-feedback-queue scheduler defined by the
following parameters:
number of queues
scheduling algorithms for each queue
method used to determine when to upgrade a
process
method used to determine when to demote a
process
method used to determine which queue a process
will enter when that process needs service
Example of Multilevel Feedback Queue
Three queues:
Q0 – RR with time quantum 8
milliseconds
Q1 – RR time quantum 16
milliseconds
Q2 – FCFS
Scheduling
A new job enters queue Q0
When it gains CPU, job
receives 8 milliseconds
If it does not finish in 8
milliseconds, job is moved
to queue Q1
At Q1 job is again served FCFS
and receives 16 additional
milliseconds
If it still does not complete,
it is preempted and moved
to queue Q2
Algorithm Evaluation
How to select CPU-scheduling algorithm for an OS?
Determine criteria, then evaluate algorithms
Deterministic modeling
Type of analytic evaluation
Takes a particular predetermined workload and
defines the performance of each algorithm for that
workload
Consider 5 processes arriving at time 0:
Deterministic Evaluation
For each algorithm, calculate minimum average waiting
time
Simple and fast, but requires exact numbers for input,
applies only to those inputs
FCS is 28ms:
Non-preemptive SFJ is 13ms:
RR is 23ms:
Queueing Models
Describes the arrival of processes, and
CPU and I/O bursts probabilistically
Commonly exponential, and
described by mean
Computes average throughput,
utilization, waiting time, etc
Computer system described as
network of servers, each with queue of
waiting processes
Knowing arrival rates and service
rates
Computes utilization, average queue
length, average wait time, etc
Little’s Formula
n = average queue length
W = average waiting time in queue
λ = average arrival rate into queue
Little’s law – in steady state, processes leaving
queue must equal processes arriving, thus:
n=λxW
Valid for any scheduling algorithm and arrival
distribution
For example, if on average 7 processes arrive
per second, and normally 14 processes in
queue, then average wait time per process = 2
seconds
Simulations
Queuing models limited
Simulations more accurate
Programmed model of computer system
Gather statistics indicating algorithm
performance
Data to drive simulation gathered via
Random number generator according to
probabilities
Distributions defined mathematically or
empirically
Trace tapes record sequences of real events
in real systems
Evaluation of CPU Schedulers by Simulation
Implementation
Even simulations have limited accuracy
Just implement new scheduler and test in
real systems
High cost, high risk
Environments vary
Most flexible schedulers can be modified
per-site or per-system
Or APIs to modify priorities
But again environments vary
