Process mgt.

: CPU Scheduling

• Basic Concepts
• Scheduling Criteria
• Scheduling Algorithms
• Multiple-Processor Scheduling
• Real-Time Scheduling
• Algorithm Evaluation

6.1
 Basic Concepts

• Objective: Maximum CPU utilization obtained with

multiprogramming
• A process is executed until it must wait - typically for
completion if I/O request, or a time quanta expires.
• CPU–I/O Burst Cycle – Process execution consists of a cycle of
CPU execution and I/O wait.

6.2
Alternating Sequence of CPU And I/O Bursts

6.3
 Histogram of CPU-burst Times

“Tune” the scheduler to these

statistics
6.4
 CPU Scheduler

• Selects from among the processes in memory that are ready to execute,
and allocates the CPU to one of them.
• CPU scheduling decisions may take place when a process:
1. Runs until it Switches from running to waiting state … stop
executing only when a needed resource or service is currently
unavailable.
2. Switches from running to ready state in the middle of a burst –
can stop execution at any time
3. Switches from waiting to ready. … ?
4. Runs until it Terminates.
• Scheduling under 1 and 4 is nonpreemptive.
• All other scheduling is preemptive.
• Under nonpremptive scheduling, once a CPU is assigned to a
process, the process keeps the CPU until it releases the CPU either
by terminating or switching to wait state - “naturally” stop
execution.

6.5
 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.

• Both scheduler and dispatcher are performance

“bottlenecks” in the OS, and must be made as fast and
efficient as possible.

6.6
 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
Or: the time from time of submission to time of completion –
includes waits in queues in addition to execute time.
• Waiting time – amount of time a process has been waiting in the
ready queue – sum of the times in ready queue - this is from
the point of view scheduler - scheduler does not look at CPU
time or I/O wait time (only ready queue time) if it minimizes
“waiting time”. .. Get a process through the ready queue as
soon as possible.
• 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.7
 Optimization Criteria

• Max CPU utilization

• Max throughput
• Min turnaround time
• Min waiting time
• Min response time

6.8
First-Come, First-Served (FCFS) Scheduling

• Example: 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

6.9
 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

6.10
 Algo for FCFS

• Input the processes along with their

burst time (bt).
• 2- Find waiting time (wt) for all
processes.
• 3- As first process that comes need
not to wait so waiting time for
process 1 will be 0 i.e. wt[0] = 0. 4-

6.11
• Find waiting time for all other
processes i.e. for process i -> wt[i] =
bt[i-1] + wt[i-1] .
• 5- Find turnaround time =
waiting_time + burst_time for all
processes.
• 6- Find average waiting time =
total_waiting_time /
no_of_processes.
6.12
• 7- Similarly, find average
turnaround time =
total_turn_around_time /
no_of_processes.

6.13
 Algo for FCFS with arrival time

• 1- Input the processes along with

their burst time(bt) and arrival
time(at)
• 2- Find waiting time for all other
processes i.e. for a given process i:
wt[i] = (bt[0] + bt[1] +...... bt[i-1]) -
at[i]

6.14
• 3- Now find turn around time =
waiting_time + burst_time for all
processes
• 4- Average waiting time =
total_waiting_time /
no_of_processes
• 5- Average turn around time =
total_turn_around_time /
no_of_processes
6.15
 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.
• Two schemes:
– nonpreemptive – once CPU given to the process it cannot
be preempted until completes its CPU burst.
– Preemptive – if a new process arrives with CPU burst
length less than remaining time of current executing
process, preempt. This scheme is know as the
Shortest-Remaining-Time-First (SRTF).
• SJF is optimal – gives minimum average waiting time for a given
set of processes.

6.16
 Example of Non-Preemptive SJF

Process Arrival Time Burst Time

P1 0.0 7
P2 2.0 4
P3 4.0 1
P4 5.0 4
• SJF (non-preemptive)

P1 P3 P2 P4

0 3 7 8 12 16
• FCFS is “tie breaker” if burst times the same.
• Average waiting time = (0 + 6 + 3 + 7)/4 - 4

6.17
 Example of Preemptive SJF
(Also called Shortest-Remaining-Time-First (SRTF) )

In order for a new

arrival to preempt, Process Arrival Time Burst Time
its burst must be
strictly less than P1 0.0 7
current remaining P2 2.0 4
time
P3 4.0 1
P4 5.0 4
• SJF (preemptive)

P1 P2 P3 P2 P4 P1

0 2 4 5 7 11 16

• Average waiting time = (9 + 1 + 0 +2)/4 = 3

6.18
 Determining Length of Next CPU Burst

• Can only estimate the length.

• Can be done by using the length of previous CPU bursts, using
exponential averaging.
1. tn  actual lenght of nthCPU burst
2.  n1  predicted value for the next CPU burst
3.  , 0    1
4. Define :

n+1 = tn + (1-  )n

n stores past history
tn is “recent history
 is a weighting factor
… recursive in n

6.19
 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 -1 + …
+(1 -  )n=1 tn 0
• Since both  and (1 - ) are less than or equal to 1, each
successive term has less weight than its predecessor.

6.20
 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 predicted next
CPU burst time.
• Problem: Starvation – low priority processes may never execute.
• Solution: Aging – as time progresses increase the priority of the
process .

6.21
 Round Robin (RR)

• Each process gets a small unit of CPU time (time quantum),

usually 10-100 milliseconds. After this time has elapsed, the
process is preempted and added to the end of the ready queue
• RR is a preemptive algorithm.
• 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.
• Performance
– q large  FIFO
– q small  q must be large with respect to context switch,
otherwise overhead is too high. ==> “processor sharing” -
user thinks it has its own processor running at 1/n speed
(n processors)

6.22
 Example: RR with Time Quantum = 20

FCFS is tie breaker Process Burst Time Assume all arrive at 0 time
P1 53 in the order given.
P2 17
P3 68
P4 24
• The Gantt chart is:

P1 P2 P3 P4 P1 P3 P4 P1 P3 P3

0 20 37 57 77 97 117 121 134 154 162

• Typically, higher average turnaround than SJF, but better response.

6.23
How a Smaller Time Quantum Increases Context Switches

Context switch overhead very critical for 3rd case -

since overhead is independent of quanta time

6.24
Turnaround Time Varies With The Time Quantum

No strict correlation of TAT

and time quanta size -
except for below

TAT can be improved if most processes finish each burst in one quanta
EX: if 3 processes each have burst of 10, then
for q = 1, avg_TAT = 29, but for q = burst = 10, avg_TAT = 20.
==> design tip: tune quanta to average burst.
6.25
 Multilevel Queue (no Feedback )

• Ready queue is partitioned into separate queues:

foreground queue (interactive)
background queue (batch)
• Each queue has its own scheduling algorithm,
foreground queue – RR
background queue – FCFS
• Scheduling must be done between the queues.
– Fixed priority scheduling; i.e., serve all from foreground then
from background. All higher priority queues must be
empty before given queue is processed. Possibility of
starvation. Assigned queue is for life of the process.
– Time slice between queues – 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

6.26
Multilevel Queue Scheduling

6.27
 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

6.28
 Multilevel Feedback Queues

Queue 0 -
High priority

Queue 1

Queue 2
Low priority

Higher priority queues

Fig 6.7 pre-empt lower priority
queues on new arrivals
6.29
 Example of Multilevel Feedback Queue

• Three queues:
– Q0 – time quantum 8 milliseconds
– Q1 – time quantum 16 milliseconds
– Q2 – FCFS
– Q2 longest jobs, with lowest priority, Q1 shortest jobs
with highest priority.
• Scheduling
– A new job enters queue Q0 which is served FCFS. When it
gains CPU, job receives 8 milliseconds. If it does not finish
in 8 milliseconds, job is moved to queue Q1(demoted).
– 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.
– Again, Qn is not served until Qn-1 empty

6.30
 Multiple-Processor Scheduling

• CPU scheduling more complex when multiple CPUs are

available.
• Homogeneous processors within a multiprocessor.
• Load sharing
• Symmetric Multiprocessing (SMP) – each processor makes its
own scheduling decisions.
• Asymmetric multiprocessing – only one processor accesses the
system data structures, alleviating the need for data sharing.

6.31
 Real-Time Scheduling

• Hard real-time systems – required to complete a critical task

within a guaranteed amount of time.
• Soft real-time computing – requires that critical processes receive
priority over less fortunate ones.
• Deadline scheduling used.

6.32
Dispatch Latency

6.33
 Solaris 2 Thread Scheduling
• 3 scheduling priority classes
– Timesharing/interactive – lowest – for users
 Within this class: Multilevel feedback queues longer time
slices in lower priority queues
– System – for kernel processes
– Real time – Highest
• Local Scheduling – How the threads library decides which thread to put
onto an available LWP. Remember threads are time multiplexed on
LWP’s
• Global Scheduling – How the kernel decides which kernel thread to run
next.
– The local schedules for each class are “globalized” from the
scheduler's point of view – all classes included.
– LPW’s scheduled by kernel

6.34
 Solaris 2 Scheduling

Only a few
in this class
Real time

Fig. 6.10 Reserved for

kernel use.
Ex: Scheduler &
paging daemon

User processes
Go here

6.35
 Java Thread Scheduling

• JVM Uses a Preemptive, Priority-Based Scheduling Algorithm.

• FIFO Queue is Used if There Are Multiple Threads With the

Same Priority.

6.36
 Java Thread Scheduling (cont)-omit

JVM Schedules a Thread to Run When:

1. The Currently Running Thread Exits the Runnable State.

2. A Higher Priority Thread Enters the Runnable State

* Note – the JVM Does Not Specify Whether Threads are Time-
Sliced or Not.

6.37
 Time-Slicing (Java) - omit

• Since the JVM Doesn’t Ensure Time-Slicing, the yield() Method

May Be Used:

while (true) {
// perform CPU-intensive task
...
Thread.yield();
}

This Yields Control to Another Thread of Equal Priority.

• Cooperative multi-tasking possible using yield

6.38
 Java Thread Priorities - omit

• Thread Priorities:

Priority Comment
Thread.MIN_PRIORITY Minimum Thread Priority
Thread.MAX_PRIORITY Maximum Thread Priority
Thread.NORM_PRIORITY Default Thread Priority

Priorities May Be Set Using setPriority() method:

setPriority(Thread.NORM_PRIORITY + 2);

6.39
 Algorithm Evaluation

• Deterministic modeling – takes a particular predetermined

workload and defines the performance of each algorithm for that
workload - what we’ve been doing in the examples - optimize
various criteria.
– Easy, but success depends on accuracy of input
• Queuing models - statistical - need field measurements of
statistics in various compouting environments

• Implementation - Costly - OK is a lot of pre-implementation done

first.

6.40
 Evaluation of CPU Schedulers by Simulation
-need good models
- drive it with field data and/or
statistical data
- could be slow.

6.41