OPERATING

SYSTEMS

OS
Lesson 4: CPU SCHEDULING
Nguyễn Thị Hậu (UET-VNU)
[email protected]

1
CONTENTS
•  Basic Concepts
•  Scheduling Criteria
•  Scheduling Algorithms
•  Algorithm Evaluation

OS
2
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

OS
•  CPU burst followed by I/O
burst
•  CPU burst distribution is of main
concern

3
 CPU Scheduler
■  The CPU scheduler selects from among the processes in ready
queue, and allocates the 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

OS
3. Switches from waiting to ready
4.  Terminates
■  Scheduling under 1 and 4 is nonpreemptive
■  All other scheduling is preemptive
●  Consider access to shared data
●  Consider preemption while in kernel mode
●  Consider interrupts occurring during crucial OS activities 4
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

OS
•  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

5
 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

OS
•  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,
not output (for time-sharing environment)

6
 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:


OS







 P1 P2 P3
0 24 27 30

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

•  Average waiting time: (0 + 24 + 27)/3 = 17
7
 FCFS Scheduling (Cont.)
Suppose that the processes arrive in the order:
P2 , P3 , P1
•  The Gantt chart for the schedule is:


P2 P3 P1

OS
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 8
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

OS
•  The difficulty is knowing the length of the next CPU request
•  Could ask the user

9
 Example of SJF

ProcessArriva l Time Burst

Time
P1 0.0 6
P2 2.0 8

OS
P3 4.0 7
P4 5.0 3

•  SJF scheduling chart

P4 P1 P3 P2
0 3 9 16 24 10

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

Determining Length of Next CPU Burst

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

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

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

OS
exponential averaging

1. t n = actual length of n th CPU burst

2. τ n +1 = predicted value for the next CPU burst
3. α , 0 ≤ α ≤ 1
4. Define : τ n=1 = α t n + (1 − α )τ n .
•  Commonly, α set to ½
•  Preemptive version called shortest-remaining-time-first 11
Prediction of the Length of the Next CPU Burst

OS
12
Example of Shortest-remaining-time-first

•  Now we add the concepts of varying arrival times and

preemption to the analysis
ProcessAarri Arrival TimeTBurst Time
P1 0 8
P2 1 4

OS
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 13

msec
 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

OS
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 ⇒ FIFO
•  q small ⇒ q must be large with respect to context switch,
otherwise overhead is too high 14
Example of RR with Time Quantum = 4
Process Burst Time
P1 24
P2 3
P3 3
•  The Gantt chart is: 




OS



 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 15
•  q usually 10ms to 100ms, context switch < 10 usec
Time Quantum and Context Switch Time

OS
16
Turnaround Time Varies With The Time Quantum

OS
80% of CPU bursts should
be shorter than q

17
 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

OS
•  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 18
Example of Priority Scheduling
ProcessAarri Burst TimeT Priority
P1 10 3
P2 1 1
P3 2 4
P4 1 5

OS
P5 5 2

•  Priority scheduling Gantt Chart

19
•  Average waiting time = 8.2 msec
Priority Scheduling w/ Round-Robin
ProcessAarri Burst TimeT Priority
P1 4 3
P2 5 2
P3 8 2
P4 7 1
P5 3 3

OS
q Run the process with the highest priority. Processes with the
same priority run round-robin

•  Gantt Chart wit 2 ms time quantum

20
 Multilevel Queue
•  With priority scheduling, have separate queues for each
priority.
•  Schedule the process in the highest-priority queue!

OS
21
Multilevel Queue
•  Prioritization based upon process type

OS
22
 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

OS
•  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

23
 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 which is served

OS
FCFS
•  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

24
ALGORITHM EVALUATION

OS
25
 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

OS
•  Consider 5 processes arriving at time 0:

26
 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:

OS
•  Non-preemptive SFJ is 13ms:

•  RR is 23ms:

27
 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

OS
•  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

28
 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:


OS
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

29
 Simulations
•  Queueing models limited
•  Simulations more accurate
•  Programmed model of computer system
•  Clock is a variable
•  Gather statistics indicating algorithm performance

OS
•  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

30
Evaluation of CPU Schedulers by Simulation

OS
31
 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

OS
■  Or APIs to modify priorities
■  But again environments vary

32
Homework
Abraham Silberschatz, Peter Baer Galvin, Greg Gagne,
Operating System Concepts, 9th edition, 2013
•  Compulsory:
Solve problem 6.3, 6.16

OS
•  Suggestion: Validate the answer by running OS Simulator
https://os-sim-os-conceptssimulator.soft112.com/

33
Thank you!

OS
Q&A

34