1. Scheduling
Algorithms
Presented By:
Shekhar Singh Tomar

2. ContentsContents
 Introduction
 Scheduling Algorithms-
 First Come, First Served (FCFS)
 Shortest Job First (SJF)
 Priority
 Round Robin (RR)

3. IntroductionIntroduction
CPU scheduling deals with the problem of deciding which
of the processes in the ready queue is to be allocated the
CPU.

4. 1- First Come, First Served (FCFS)1- First Come, First Served (FCFS)
SchedulingScheduling
 Implementation:
As each process becomes ready, it joins the ready queue.
When the current process finishes, the oldest process is selected
next.
 Characteristics:
Simple to implement
Non-preemptive

5. First-Come, First-Served (FCFS)First-Come, First-Served (FCFS)
SchedulingScheduling
Example- Process Burst Time
P1 24
P2 3
P3 3
 With FCFS, the process that requests the CPU first is allocated the CPU first
 Case 1: Suppose that the processes arrive in the order: P1 , P2 , P3
The Chart for the schedule is:
 Waiting time for P1 = 0; P2 = 24; P3 = 27
 Average waiting time: (0 + 24 + 27)/3 = 17
 Average turn-around time: (24 + 27 + 30)/3 = 27
P1 P2 P3
24 27 300

6. FCFS Scheduling (Cont.)FCFS Scheduling (Cont.)
 Case 2: Suppose that the processes arrive in the order: P2 , P3 , P1
 The 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 Case #1)
 Average turn-around time: (3 + 6 + 30)/3 = 13
P1P3P2
63 300

7. 2-Shortest-Job-First (SJF) Scheduling2-Shortest-Job-First (SJF) Scheduling
 The SJF algorithm associates with each process the length of its
next CPU burst
 When the CPU becomes available, it is assigned to the process
that has the smallest next CPU burst (in the case of matching
bursts, FCFS is used)
 Two schemes:
Non-preemptive – once the CPU is given to the process, it
cannot be preempted until it completes its CPU burst.
Preemptive – It will preempt the currently executing process.
This scheme is know as the Shortest-Remaining-Time-First
(SRTF)

8. SJF Scheduling…SJF Scheduling…
Exponential Averaging
 Estimation based on historical data
 tn = length of the nth CPU burst
 τn = Estimate for nth CPU burst (stores past history)
 τn+1 = predicted value for n+1st
or next CPU burst
 α, 0 ≤ α 1≤
τn+1 = αtn + (1- α) τn
09/24/13 8

9. Process Arrival Time Burst Time
P1 0.0 6
P2 0.0 4
P3 0.0 1
P4 0.0 5
SJF (non-preemptive, simultaneous arrival)
Average waiting time = (0 + 1 + 5 + 10)/4 = 4
Average turn-around time = (1 + 5 + 10 + 16)/4 = 8
Example 1: Non-Preemptive SJFExample 1: Non-Preemptive SJF
(simultaneous arrival)(simultaneous arrival)
P1P3 P2
51 160
P4
10

10. Process Arrival Time Burst Time
P1 0.0 7
P2 2.0 4
P3 4.0 1
P4 5.0 4
SJF (non-preemptive, varied arrival times)
Average waiting time
= ( (0 – 0) + (8 – 2) + (7 – 4) + (12 – 5) )/4
= (0 + 6 + 3 + 7)/4 = 4
Average turn-around time:
= ( (7 – 0) + (12 – 2) + (8 - 4) + (16 – 5))/4
= ( 7 + 10 + 4 + 11)/4 = 8
Example 2: Non-Preemptive SJFExample 2: Non-Preemptive SJF
(varied arrival times)(varied arrival times)
P1 P3 P2
73 160
P4
8 12
Waiting time : sum of time that a process has spent waiting in the ready queue

11. Example 3: Preemptive SJFExample 3: Preemptive SJF
(Shortest-remaining-time-first)(Shortest-remaining-time-first)
Process Arrival Time Burst Time
P1 0.0 7
P2 2.0 4
P3 4.0 1
P4 5.0 4
SJF (preemptive , varied arrival times)
Average waiting time
= ( [(0 – 0) + (11 - 2)] + [(2 – 2) + (5 – 4)] + (4 - 4) + (7 – 5) )/4
= 9 + 1 + 0 + 2)/4
= 3
Average turn-around time = (16 + 7 + 5 + 11)/4 = 9.75
P1 P3P2
42 110
P4
5 7
P2 P1
16
Waiting time : sum of time that a process has spent waiting in the ready queue

12. 3- Priority Scheduling3- Priority Scheduling
 The SJF algorithm is a special case of the general priority scheduling
algorithm
 Each process (or class of processes) is given a priority (integer
number).
 The CPU is allocated to the process with the highest priority (smallest
integer = highest priority)
 Priority scheduling can be either preemptive or non-preemptive
A preemptive approach will preempt the CPU if the priority of the
newly-arrived process is higher than the priority of the currently
running process
A non-preemptive approach will simply put the new process
(with the highest priority) at the head of the ready queue
 SJF is a priority scheduling algorithm where priority is the predicted
next CPU burst time.
 The main problem with priority scheduling is starvation, that is, low
priority processes may never execute.
 A solution is aging; as time progresses, the priority of a process in the
ready queue is increased

13. Example of Priority SchedulingExample of Priority Scheduling
Process Burst time Priority
P1 10 3
P2 1 1
P3 2 4
P4 1 5
P5 5 2
0 1 6 16 18 19
Average wating time = (6+0+16+18+1)/5=8.2 milliseconds
P2 P5 P1 P3 P4

14. 4- Round-Robin Scheduling4- Round-Robin Scheduling
 Developed in response to time-sharing systems.
 Each process gets a small unit of CPU time (time quantum),
 Each job is given control of the CPU for that time quantum.
(In the range of 10-100 milliseconds.)
 Control then passes to the next job (FIFO?)
 Average waiting time dependent on job size, quantum size
 RR scheduling algorithm is preemptive.

15. Example of RR with Time Quantum =Example of RR with Time Quantum =
44
Process Burst Time
P1 24
P2 3
P3 3
 The chart is:
 Typically, higher average turnaround than SJF, but better response.
P1 P2 P3 P1 P1 P1 P1 P1
0 4 7 10 14 18 22 26 30

16. Time Quantum and Context SwitchTime Quantum and Context Switch
TimeTime

17. Thank YouThank You