Chapter 5: CPU Scheduling

Operating System Concepts – 10th Edition Silberschatz, Galvin and Gagne ©2018
 Outline
▪ Basic Concepts
▪ Scheduling Criteria
▪ Scheduling Algorithms
▪ Thread Scheduling
▪ Multi-Processor Scheduling
▪ Real-Time CPU Scheduling
▪ Linux Example

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

Operating System Concepts – 10th Edition 5.4 Silberschatz, Galvin and Gagne ©2018
 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 ©2018
 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 ©2018
 Preemptive and Nonpreemptive Scheduling

▪ When scheduling takes place only under circumstances 1 and 4, the

scheduling scheme is nonpreemptive (sin desalojo).
▪ Otherwise, it is preemptive (apropiativo).
▪ Under Nonpreemptive 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.
▪ Preemptive scheduling can result in race conditions when data are
shared among several processes.
▪ 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 ©2018
 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 – time it takes for the
dispatcher to stop one process and start
another running

Operating System Concepts – 10th Edition 5.8 Silberschatz, Galvin and Gagne ©2018
 Scheduling Criteria

▪ CPU utilization – keep the CPU as busy as possible

▪ Throughput (tasa de procesamiento) – # of processes that
complete their execution per time unit
▪ Turnaround time (tiempo de ejecución) – amount of time it
takes from when a request was submitted until the process is
terminated.
▪ Response time – amount of time it takes from when a request was
submitted until the first response is produced.
▪ Waiting time – amount of time a process has been waiting in the
ready queue

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

▪ Max CPU utilization

▪ Max throughput
▪ Min turnaround time
▪ Min waiting time
▪ Min response time

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

▪ Waiting time for P1 = 0; P2 = 24; P3 = 27

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

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

Suppose that the processes arrive in the order:

P2 , P 3 , P 1
▪ The Gantt chart for the schedule is:

▪ 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.12 Silberschatz, Galvin and Gagne ©2018
 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

Operating System Concepts – 10th Edition 5.13 Silberschatz, Galvin and Gagne ©2018
 Example of SJF

ProcessABurst Time
P1 0.0 6
P2 2.0 8
P3 4.0 7
P4 5.0 3

▪ SJF scheduling chart

▪ Average waiting time = (3 + 16 + 9 + 0) / 4 = 7

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

Operating System Concepts – 10th Edition 5.15 Silberschatz, Galvin and Gagne ©2018
 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 at most q time
units at once. No process waits more than (n-1)q time units.
▪ Timer interrupts every quantum to schedule next process
▪ Performance
• q large ⇒ FCFS
• q small ⇒ q must be large with respect to context switch, otherwise
overhead is too high

Operating System Concepts – 10th Edition 5.16 Silberschatz, Galvin and Gagne ©2018
 Example of RR with Time Quantum = 4

Process Burst Time

P1 24
P2 3
P3 3
▪ The Gantt chart is:

▪ 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.17 Silberschatz, Galvin and Gagne ©2018
 Time Quantum and Context Switch Time

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

▪ Shortest-Job-First is priority scheduling where priority is the inverse of

predicted next CPU burst time

▪ Problem ≡ Starvation – low priority processes may never execute

▪ Solution ≡ Aging (envejecimiento) – as time progresses increase the priority

of the process

Operating System Concepts – 10th Edition 5.19 Silberschatz, Galvin and Gagne ©2018
 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.20 Silberschatz, Galvin and Gagne ©2018
 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.21 Silberschatz, Galvin and Gagne ©2018
 Multilevel Queue
▪ With priority scheduling, have separate queues for each priority.

Operating System Concepts – 10th Edition 5.22 Silberschatz, Galvin and Gagne ©2018
 Multilevel Queue

▪ Prioritization based upon process type

Operating System Concepts – 10th Edition 5.23 Silberschatz, Galvin and Gagne ©2018
 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 multilevel feedback queue

Operating System Concepts – 10th Edition 5.24 Silberschatz, Galvin and Gagne ©2018
 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
4 When it gains CPU, the process receives 8
milliseconds
4 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
4 If it still does not complete, it is preempted and
moved to queue Q2

Operating System Concepts – 10th Edition 5.25 Silberschatz, Galvin and Gagne ©2018
 User vs kernel thread Scheduling
▪ Distinction between user-level and kernel-level threads
▪ When threads 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 programmer
▪ Kernel thread scheduled onto available CPU is system-contention scope
(SCS) – competition among all threads in system

Lab posix-sched.c

Operating System Concepts – 10th Edition 5.26 Silberschatz, Galvin and Gagne ©2018
 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.27 Silberschatz, Galvin and Gagne ©2018
 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.28 Silberschatz, Galvin and Gagne ©2018
 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); Lab posix-sched.c
}

Operating System Concepts – 10th Edition 5.29 Silberschatz, Galvin and Gagne ©2018
 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.30 Silberschatz, Galvin and Gagne ©2018
 Multicore Processors
▪ Recent trend to place multiple processor cores on 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.31 Silberschatz, Galvin and Gagne ©2018
 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.32 Silberschatz, Galvin and Gagne ©2018
 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.33 Silberschatz, Galvin and Gagne ©2018
 Multithreaded Multicore System

▪ Two levels of scheduling:

1. The operating system

deciding 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.34 Silberschatz, Galvin and Gagne ©2018
 Multiple-Processor Scheduling – Load Balancing

▪ If SMP, need 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 pulls waiting task from busy
processor

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

Processor Affinity

Operating System Concepts – 10th Edition 5.36 Silberschatz, Galvin and Gagne ©2018
 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.37 Silberschatz, Galvin and Gagne ©2018
 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 – time
from arrival of interrupt to
start of 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.38 Silberschatz, Galvin and Gagne ©2018
 Priority-based Scheduling
▪ For real-time scheduling, scheduler must support preemptive, priority-based
scheduling
• But only guarantees soft real-time
▪ For hard real-time must also provide ability to meet deadlines
▪ Processes have new characteristics: periodic ones require CPU at constant
intervals
• Has processing time t, deadline d, period p
• 0≤t≤d≤p

Operating System Concepts – 10th Edition 5.39 Silberschatz, Galvin and Gagne ©2018
 POSIX Real-Time Scheduling API
#include <pthread.h>
#include <stdio.h>
#define NUM_THREADS 5
int main(int argc, char *argv[])
{
int i, policy;
pthread_t_tid[NUM_THREADS];
pthread_attr_t attr;
/* get the default attributes */
pthread_attr_init(&attr);
/* get the current scheduling policy */
if (pthread_attr_getschedpolicy(&attr, &policy) != 0)
fprintf(stderr, "Unable to get policy.\n");
else {
if (policy == SCHED_OTHER) printf("SCHED_OTHER\n");
else if (policy == SCHED_RR) printf("SCHED_RR\n");
else if (policy == SCHED_FIFO) printf("SCHED_FIFO\n");
}

Operating System Concepts – 10th Edition 5.40 Silberschatz, Galvin and Gagne ©2018
 POSIX Real-Time Scheduling API (Cont.)

/* set the scheduling policy - FIFO, RR, or OTHER */

if (pthread_attr_setschedpolicy(&attr, SCHED_FIFO) != 0)
fprintf(stderr, "Unable to set policy.\n");
/* 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 ... */
Lab posix-rt.c
pthread_exit(0);
}

Operating System Concepts – 10th Edition 5.41 Silberschatz, Galvin and Gagne ©2018
 Linux Scheduling Version 2.6.23 +
▪ Preemptive, priority based
▪ Two priority ranges: time-sharing and real-time
▪ Real-time range from 0 to 99 and time-sharing from 100 to 140
▪ Higher priority gets larger q
▪ Completely Fair Scheduler (CFS)
▪ Real-time scheduling according to POSIX.1b
▪ Quantum calculated based on nice value from -20 to +19
• Lower value is higher priority
▪ Nice value of -20 maps to global priority 100
▪ Nice value of +19 maps to priority 139

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

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