Chapter 5: CPU Scheduling

Operating System Concepts – 10th Edition Silberschatz, Galvin and Gagne

 Outline
 Basic Concepts
 Scheduling Criteria
 Scheduling Algorithms
 Thread Scheduling
 Multi-Processor Scheduling
 Real-Time CPU Scheduling
 Operating Systems Examples
 Algorithm Evaluation

Operating System Concepts – 10th Edition 5.2 Silberschatz, Galvin and Gagne
 Objectives

 Describe various CPU scheduling algorithms

 Assess CPU scheduling algorithms based on scheduling
criteria
 Explain the issues related to multiprocessor and
multicore scheduling
 Describe various real-time scheduling algorithms
 Describe the scheduling algorithms used in the
Windows, Linux, and Solaris operating systems
 Apply modeling and simulations to evaluate CPU
scheduling algorithms

Operating System Concepts – 10th Edition 5.3 Silberschatz, Galvin and Gagne
 Basic Concepts

 Maximum CPU utilization

obtained with multiprogramming

 CPU–I/O Burst Cycle – Process

execution consists of a cycle of
CPU execution and I/O wait

 CPU burst followed by I/O burst

 CPU burst distribution is of main

concern

Operating System Concepts – 10th Edition 5.4 Silberschatz, Galvin and Gagne
 Histogram of CPU-burst Times

Large number of short bursts

Small number of longer bursts

Operating System Concepts – 10th Edition 5.5 Silberschatz, Galvin and Gagne
 CPU Scheduler
 The CPU scheduler selects from among the processes
in ready queue and allocates a CPU core 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
 For situations 1 and 4, there is no choice in terms of
scheduling. A new process (if one exists in the ready
queue) must be selected for execution.
 For situations 2 and 3, however, there is a choice.

Operating System Concepts – 10th Edition 5.6 Silberschatz, Galvin and Gagne
 Preemptive and Nonpreemptive Scheduling

 When scheduling takes place only under circumstances 1

and 4, the scheduling scheme is non-preemptive.

 Otherwise, it is preemptive.

 Under Non preemptive scheduling, once the CPU has been

allocated to a process, the process keeps the CPU until it
releases it either by terminating or by switching to the
waiting state.

 Virtually all modern operating systems including Windows,

MacOS, Linux, and UNIX use preemptive scheduling
algorithms.

Operating System Concepts – 10th Edition 5.7 Silberschatz, Galvin and Gagne
 Preemptive Scheduling and Race Conditions

 Preemptive scheduling can result in race conditions

when data are shared among several processes.

 Consider the case of two processes that share data.

While one process is updating the data, it is preempted
so that the second process can run. The second process
then tries to read the data, which are in an inconsistent
state.

 This issue will be explored in detail in Chapter 6.

Operating System Concepts – 10th Edition 5.8 Silberschatz, Galvin and Gagne
 Dispatcher
 Dispatcher module gives control
of the CPU to the process
selected by the CPU scheduler;
this involves:
• Switching context
• Switching to user mode
• Jumping to the proper location
in the user program to restart
that program
 Dispatch latency – the time it takes
for the dispatcher to stop one
process and start another running

Operating System Concepts – 10th Edition 5.9 Silberschatz, Galvin and Gagne
 Scheduling Criteria

 CPU utilization – keep the CPU as busy as

possible
 Throughput – # of processes that complete their
execution per time unit
 Turnaround time – amount of time to execute a
particular process
 Waiting time – amount of time a process has
been waiting in the ready queue
 Response time – amount of time it takes from
when a request was submitted until the first
response is produced.

Operating System Concepts – 10th Edition 5.10 Silberschatz, Galvin and Gagne
 Scheduling Algorithm Optimization Criteria

 Max CPU utilization

 Max throughput
 Min turnaround time
 Min waiting time
 Min response time

Operating System Concepts – 10th Edition 5.11 Silberschatz, Galvin and Gagne
 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 P1 = 0; P2 = 24; P3 = 27

 Average waiting time: (0 + 24 + 27)/3 = 17

Operating System Concepts – 10th Edition 5.12 Silberschatz, Galvin and Gagne
 FCFS Scheduling (Cont.)

Suppose that the processes arrive in the order:

P2 , P3 , P1
 The Gantt chart for the schedule is:

P2 P3 P1
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
• Consider one CPU-bound and many I/O-bound
processes

Operating System Concepts – 10th Edition 5.13 Silberschatz, Galvin and Gagne
 Shortest-Job-First (SJF) Scheduling

 Associate with each process the length of its next CPU

burst
• Use these lengths to schedule the process in 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
• Could ask the user

Operating System Concepts – 10th Edition 5.14 Silberschatz, Galvin and Gagne
 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
 Preemptive version called shortest-remaining-time-
first
 How do we determine the length of the next CPU
burst?
• Could ask the user
• Estimate

Operating System Concepts – 10th Edition 5.15 Silberschatz, Galvin and Gagne
 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

Operating System Concepts – 10th Edition 5.16 Silberschatz, Galvin and Gagne
 Determining Length of Next CPU Burst

 Can only estimate the length – should be similar to the

previous one
• Then pick the process with the shortest predicted
next CPU burst

 Can be done by using the length of previous CPU bursts,

using exponential averaging
th
1. t n  actual length of n CPU burst
2.  n 1  predicted value for the next CPU burst
3.  , 0    1
4. Define :

 Commonly, α set to ½

Operating System Concepts – 10th Edition 5.17 Silberschatz, Galvin and Gagne
 Prediction of the Length of the Next CPU Burst

Operating System Concepts – 10th Edition 5.18 Silberschatz, Galvin and Gagne
 Examples of Exponential Averaging
  =0
• n+1 = n
• Recent history does not count
  =1
• n+1 =  tn
• Only the actual last CPU burst counts
 If we expand the formula, we get:
n+1 =  tn+(1 - ) tn -1 + …
+(1 -  )j  tn -j + …
+(1 -  )n +1 0

 Since both  and (1 - ) are less than or equal to 1, each

successive term has less weight than its predecessor

Operating System Concepts – 10th Edition 5.19 Silberschatz, Galvin and Gagne
 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

Operating System Concepts – 10th Edition 5.20 Silberschatz, Galvin and Gagne
 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.

 If there are n processes in the ready queue and the time

quantum is q, then each process gets 1/n of the CPU time
in chunks of most q time units at once. No process waits
for more than (n-1)q time units.

 Timer interrupts every quantum to schedule the next

process

 Performance
• q large  FIFO
• q small  q must be large with respect to context
switch, otherwise overhead is too high
Operating System Concepts – 10th Edition 5.21 Silberschatz, Galvin and Gagne
 Example of RR with Time Quantum = 4

Process Burst Time

P1 24
P2 3
3 P3
 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
 q should be large compared to context switch time
• q usually 10 milliseconds to 100 milliseconds,
• Context switch < 10 microseconds

Operating System Concepts – 10th Edition 5.22 Silberschatz, Galvin and Gagne
 Time Quantum and Context Switch Time

Operating System Concepts – 10th Edition 5.23 Silberschatz, Galvin and Gagne
 Turnaround Time Varies With The Time Quantum

80% of CPU bursts

should be shorter
than q

Operating System Concepts – 10th Edition 5.24 Silberschatz, Galvin and Gagne
 Priority Scheduling

 A priority number (integer) is associated with each

process

 The CPU is allocated to the process with the highest

priority (smallest integer  highest priority)
• Preemptive
• Nonpreemptive

 SJF is a priority scheduling where priority is the inverse

of the predicted next CPU burst time

 Problem  Starvation – low priority processes may never

execute

 Solution  Aging – as time progresses increase the

priority of the process

Operating System Concepts – 10th Edition 5.25 Silberschatz, Galvin and Gagne
 Example of Priority Scheduling

ProcessA arri Burst TimeT Priority

P1 10 3
P2 1 1
P3 2 4
P4 1 5
P5 5 2

 Priority scheduling Gantt Chart

 Average waiting time = 8.2

Operating System Concepts – 10th Edition 5.26 Silberschatz, Galvin and Gagne
 Priority Scheduling w/ Round-Robin
ProcessA arri Burst TimeT
Priority
P1 4 3
P2 5 2
P3 8 2
P4 7 1
P5 3 3
 Run the process with the highest priority. Processes
with the same priority run round-robin

 Gantt Chart with time quantum = 2

Operating System Concepts – 10th Edition 5.27 Silberschatz, Galvin and Gagne
 Multilevel Queue
 With priority scheduling, have separate queues for each
priority.
 Schedule the process in the highest-priority queue!

Operating System Concepts – 10th Edition 5.28 Silberschatz, Galvin and Gagne
 Multilevel Queue

 Prioritization based upon process type

Operating System Concepts – 10th Edition 5.29 Silberschatz, Galvin and Gagne
 Multilevel Feedback Queue
 A process can move between the various queues.
 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
 Aging can be implemented using a multilevel
feedback queue

Operating System Concepts – 10th Edition 5.30 Silberschatz, Galvin and Gagne
 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 process enters queue Q0
which is served in RR
 When it gains CPU, the process
receives 8 milliseconds
 If it does not finish in 8
milliseconds, the process is moved
to queue Q1
• At Q1 job is again served in RR
and receives 16 additional
milliseconds
 If it still does not complete, it is
preempted and moved to queue Q2

Operating System Concepts – 10th Edition 5.31 Silberschatz, Galvin and Gagne
 Thread Scheduling
 Distinction between user-level and kernel-level threads

 When threads are supported, threads scheduled, not

processes

 Many-to-one and many-to-many models, thread library

schedules user-level threads to run on LWP
• Known as process-contention scope (PCS) since
scheduling competition is within the process
• Typically done via priority set by the programmer

 Kernel thread scheduled onto available CPU is system-

contention scope (SCS) – competition among all threads in
the system

Operating System Concepts – 10th Edition 5.32 Silberschatz, Galvin and Gagne
 Pthread Scheduling
 API allows specifying either PCS or SCS during thread
creation
• PTHREAD_SCOPE_PROCESS schedules threads using
PCS scheduling
• PTHREAD_SCOPE_SYSTEM schedules threads using
SCS scheduling
 Can be limited by OS – Linux and macOS only allow
PTHREAD_SCOPE_SYSTEM

Operating System Concepts – 10th Edition 5.33 Silberschatz, Galvin and Gagne
 Pthread Scheduling API
#include <pthread.h>
#include <stdio.h>
#define NUM_THREADS 5
int main(int argc, char *argv[]) {
int i, scope;
pthread_t tid[NUM THREADS];
pthread_attr_t attr;
/* get the default attributes */
pthread_attr_init(&attr);
/* first inquire on the current scope */
if (pthread_attr_getscope(&attr, &scope) != 0)
fprintf(stderr, "Unable to get scheduling scope\n");
else {
if (scope == PTHREAD_SCOPE_PROCESS)
printf("PTHREAD_SCOPE_PROCESS");
else if (scope == PTHREAD_SCOPE_SYSTEM)
printf("PTHREAD_SCOPE_SYSTEM");
else
fprintf(stderr, "Illegal scope value.\n");
}

Operating System Concepts – 10th Edition 5.34 Silberschatz, Galvin and Gagne
 Pthread Scheduling API

/* set the scheduling algorithm to PCS or SCS */

pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
/* create the threads */
for (i = 0; i < NUM_THREADS; i++)
pthread_create(&tid[i],&attr,runner,NULL);
/* now join on each thread */
for (i = 0; i < NUM_THREADS; i++)
pthread_join(tid[i], NULL);
}
/* Each thread will begin control in this function */
void *runner(void *param)
{
/* do some work ... */
pthread_exit(0);
}

Operating System Concepts – 10th Edition 5.35 Silberschatz, Galvin and Gagne
 Multiple-Processor Scheduling
 CPU scheduling is more complex when multiple CPUs are
available

 Multiprocess may be any one of the following

architectures:
• Multicore CPUs
• Multithreaded cores
• NUMA systems
• Heterogeneous multiprocessing

Operating System Concepts – 10th Edition 5.36 Silberschatz, Galvin and Gagne
 Multiple-Processor Scheduling

 Symmetric multiprocessing (SMP) is where each

processor is self-scheduling.
 All threads may be in a common ready queue (a)
 Each processor may have its own private queue of
threads (b)

Operating System Concepts – 10th Edition 5.37 Silberschatz, Galvin and Gagne
 Multicore Processors
 Recent trend to place multiple processor cores on the
same physical chip

 Faster and consumes less power

 Multiple threads per core also growing

• Takes advantage of memory stall to make progress on
another thread while memory retrieve happens

 Figure

Operating System Concepts – 10th Edition 5.38 Silberschatz, Galvin and Gagne
 Multithreaded Multicore System
 Each core has > 1 hardware threads.

 If one thread has a memory stall, switch to another

thread!

 Figure

Operating System Concepts – 10th Edition 5.39 Silberschatz, Galvin and Gagne
 Multithreaded Multicore System
 Chip-multithreading (CMT)
assigns each core multiple
hardware threads. (Intel
refers to this as
hyperthreading.)

 On a quad-core system with

2 hardware threads per
core, the operating system
sees 8 logical processors.

Operating System Concepts – 10th Edition 5.40 Silberschatz, Galvin and Gagne
 Multithreaded Multicore System

 Two levels of
scheduling:

1. The operating
system decides
which software
thread to run on a
logical CPU

2. How each core

decides which
hardware thread to
run on the physical
core.

Operating System Concepts – 10th Edition 5.41 Silberschatz, Galvin and Gagne
 Multiple-Processor Scheduling – Load Balancing

 If SMP, needs to keep all CPUs loaded for efficiency

 Load balancing attempts to keep workload evenly

distributed

 Push migration – periodic task checks load on each

processor, and if found pushes task from overloaded
CPU to other CPUs

 Pull migration – idle processors pull waiting task from

the busy processor

Operating System Concepts – 10th Edition 5.42 Silberschatz, Galvin and Gagne
 Multiple-Processor Scheduling – Processor Affinity

 When a thread has been running on one processor, the

cache contents of that process or store the memory
accesses by that thread.
 We refer to this as a thread having an affinity for a
processor (i.e., “processor affinity”)
 Load balancing may affect processor affinity as a thread
may be moved from one processor to another to balance
loads, yet that thread loses the contents of what it had in
the cache of the processor it was moved off of.
 Soft affinity – the operating system attempts to keep a
thread running on the same processor, but no
guarantees.
 Hard affinity – allows a process to specify a set of
processors it may run on.

Operating System Concepts – 10th Edition 5.43 Silberschatz, Galvin and Gagne
 NUMA and CPU Scheduling
If the operating system is NUMA-aware, it will assign
memory closes to the CPU the thread is running on.

Operating System Concepts – 10th Edition 5.44 Silberschatz, Galvin and Gagne
 Real-Time CPU Scheduling
 Can present obvious challenges
 Soft real-time systems – Critical real-time tasks have the
highest priority, but no guarantee as to when tasks will
be scheduled
 Hard real-time systems – task must be serviced by its deadline

Operating System Concepts – 10th Edition 5.45 Silberschatz, Galvin and Gagne
 Real-Time CPU Scheduling
 Event latency – the
amount of time that
elapses from when an
event occurs to when it is
serviced.
 Two types of latencies
affect performance
1. Interrupt latency – the
time from the arrival of
interrupt to the start of
a routine that services
interrupt

2. Dispatch latency –
time for schedule to
take current process
off CPU and switch to
another
Operating System Concepts – 10th Edition 5.46 Silberschatz, Galvin and Gagne
 Interrupt Latency

Operating System Concepts – 10th Edition 5.47 Silberschatz, Galvin and Gagne
 Dispatch Latency

 Conflict phase of
dispatch latency:
1. Preemption of any
process running in
kernel mode
2. Release by the low-
priority process of
resources needed by
high-priority
processes

Operating System Concepts – 10th Edition 5.48 Silberschatz, Galvin and Gagne
 End of Chapter 5

Operating System Concepts – 10th Edition Silberschatz, Galvin and Gagne