Skip to main content
Link
Menu
Expand
(external link)
Document
Search
Copy
Copied
Search cs492-stevens
Lectures
Lecture 15 Annotated
15 - Scheduling (2)
Outline
Batch Systems Scheduling
First Come, First Serve (FCFS)
Announcements
Reading:
Batch Systems Scheduling (FCFS, SJF)
Interactive Systems Scheduling (Round Robin)
Round Robin vs. FCFS
Assumptions:
Algorithms:
A First-In, First-Out (FIFO) queue.
Example:
Turnaround Time =
Turnaround Time:
Average TT = 13
P1: TT = (30 - 0) = 30
P3: TT = (6 - 0) = 6
P2: TT = (3 - 0) = 3
(completion time - release time)
or
(wait time + running time)
Average Turnaround Time =
e.g. even though P3 is short, its turnaround time is
very long since P1 arrived first.
Convoy Effect: Long-running processes delay turnaround
time for shorter processes.
When we change the arrival order: P2, P3, P1
Takeaway: The convoy effect makes FCFS a poor choice.
Assumption: Each job's processing time is already known
Schedule the next job with the shortest processing time
Processes become available
in order: P1, P2, P3
Goals:
Will release PA 3 instructions by tomorrow.
Quiz 2 this Friday
1)
2)
3)
MOS 2.4
-
-
-
-
-
-
-
-
each job's processing time is known (for SJF)
jobs are assigned to CPU in order of release time
non-preemptive: jobs are run-to-completion
Throughput
First Come, First Serve (FCFS)
Shortest Job First (SJF)
batch system tasks are often repetitive, so processing time can
be measured and/or approximated
e.g. time to process monthly payroll would be approximately same
P1
P1: TT = 24 - 0 = 24
0
24
3
3
0
0
Release
Time
Processing
Time
P2
P2: TT = 27 - 0 = 27
P3
P3: TT = 30 - 0 = 30
P2
P3
P1
t = 0
ready:
P1
P2
P3
t = 24
ready:
P2
P3
t = 27
ready:
P3
t = 30
ready:
t = 0
ready:
P2
P3
P1
t = 3
ready:
P3
P1
t = 6
ready:
P1
t = 30
ready:
Shortest Job First (SJF)
-
-
Non-preemptive:
Example:
Non-preemptive:
Preemptive:
SRTN minimizes average turnaround time.
SRTN Disadvantages:
Starvation:
would need to modify SJF to prevent starvation
A job never completes due to being
continuously preempted
- jobs are run-to-completion
- Shortest Remaining Time Next (SRTN)
- kernel switches jobs if another arrives
with shorter remaining processing time
Preemptive:
only valid when performing same tasks (measured time)
otherwise you can't avoid convoy effect
P1
0
7
4
1
4
2
4
5
Release
Time
Processing
Time
P2
P3
P4
t = 0
ready:
P1 (p=7)
t = 7
ready:
P2 (p=4)
P3 (p=1)
P4 (p=4)
t = 8
ready:
P2 (p=4)
P4 (p=4)
t = 12
ready:
P4 (p=4)
t = 16
ready:
P4 (p=4)
P1
P1
P2
P2
P3
P3
P4
P4
t = 0
ready:
P1 (p=7)
t = 2
ready:
P1 (p=5)
P2 (p=4)
t = 4
ready:
P1 (p=5)
P2 (p=2)
P3 (p=1)
t = 5
ready:
P1 (p=5)
P2 (p=2)
P4 (p=4)
t = 7
ready:
P1 (p=5)
P4 (p=4)
t = 11
ready:
P1 (p=5)
t = 16
ready:
P1
P1
P2
P2
P3
P3
P4
P4
-
-
-
requires known processing times (unrealistic)
more context switching (switching overhead)
potentially starves jobs
Turnaround Time:
Average TT = 8
Turnaround Time:
P1: TT = 7
P1: TT =
P3: TT = 12 - 4 = 8
P3: TT =
P4: TT = 16 - 5 = 11
P4: TT =
P2: TT = 8 -2 = 6
P2: TT =
Interactive Systems Scheduling
Algorithms:
Each job runs for specified time quantum
After time quantum elapsed:
If job terminates or blocks:
An old, popular algorithm.
Note: release time only
determines position in queue
Assume ascending order.
Assume time quantum = 20
Example:
Goals:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
Response Time
(not necessarily completion)
Proportionality
Round Robin
Priority Scheduling
Multiple Queues
time quantum = fixed time interval
running job suspended (preempted)
job loses rest of quantum
simple: it's a FIFO queue
fair: every job is guaranteed processing time
next job in ready queue immediately runs
job added to the end of the ready queue
next job in ready queue runs
requires preemption via clock interrupt
Average Turnaround Time
CPU Utilization
Round Robin (RR)
P1
52
8
66
24
Processing
Time
P2
P3
P4
t = 0
ready:
P1:52
P2:8
P3:66
P4:24
t = 20
ready:
P2:8
P3:66
P4:24
P1:32
t = 28
ready:
P3:66
P4:24
P1:32
t = 48
ready:
P4:24
P1:32
P3:46
t = 68
ready:
P1:32
P3:46
P4:4
t = 88
ready:
P3:46
P4:4
P1:12
t = 108
ready:
P4:4
P1:12
P3:26
t = 112
ready:
P1:12
P3:26
t = 124
ready:
P3:26
t = 150
ready:
P1
P2
P3
P4
Waiting Time:
Selection depends on:
Average =
Average =
Turnaround Time:
P1: WT =
P1: TT =
P3: WT =
P3: TT =
P4: WT =
P4: TT =
P2: WT =
P2: TT =
Selecting the Time Quantum
Exercise
PollEv
-
-
-
context switching time (quantum >> switching)
Longer quantum => increase response time
Shorter quantum => higher switching overhead
Note: nowadays, time quantum is not fixed
Given:
When will the 50th job start?
switching time = 1ms, quantum = 4ms => 20% time switching
more jobs => increases response time for jobs at end of queue
want switching to be < 1% of total CPU time
usually switching order ~us, quantum order ~ms, 1000x longer
=> requires interrupt frequency ~100Hz - 1000Hz
number of jobs
kernel can decide a quantum on per-job basis
quantum = 100ms
switching time = 1ms
50 jobs in queue with p > quantum
Advantages:
Disadvantages:
-
-
all jobs guaranteed CPU time
=> no starvation
accumulates switching time
increases average waiting time
different processing times
=> low average waiting time
not too many jobs in queue
=> good response time
-
-
-
-
-
Fairness
Many long jobs
Few, diverse jobs
FCFS vs. RR
Consider the following scenario:
Round Robin is bad when the job lengths are long
and the same.
FCFS has better cache efficiency and switching.
When quantum > max processing time, RR = FCFS
FCFS:
Average TT = 550ms
Num switches = 9
Num switches = 999
Average TT = 995.5ms
RR:
10 jobs, 100ms processing time each
RR time quantum = 1ms
All jobs are released simultaneously
RR causes cache misses, increasing switch time
P1
P1
100
991
200
992
...
...
1000
1000
Completion
Time
Completion
Time
P2
P2
...
...
P10
P10
P1
53
8
68
24
Processing
Time
P2
P3
P4
Revisit RR Example:
WT
Scenario
Best FCFS
Best FCFS
32
85
0
8
85
153
8
32
57
81
58
82
56
80
68
92
88
112
121
145
31.25
69.5
62
100.5
61.25
99.5
61.25
99.5
66.25
104.5
83.5
121.75
57.25
95.5
85
153
85
153
85
153
85
153
85
153
0
68
22
30
20
28
8
16
10
18
20
28
145
153
84
137
82
135
80
133
82
135
72
137
68
121
Q = 1
Q = 1
Q = 5
Q = 5
Q = 8
Q = 8
Q = 10
Q = 10
Q = 20
Q = 20
Worst FCFS
Worst FCFS
P1
P2
P3
P4
Average
TT
Best-case FCFS (no convoy):
Worst-case FCFS is reverse.
P2
8
P4
24
P1
53
P3
68
t = 8
t = 32
t = 85
t = 153
t = 0
P1
P2
P2
P2 Waiting
= (24 + 27 + 30) / 3 = 27
16
5
1
6
Average TT = 7
(68-20)+(112-88) = 72
124
28
150
112
103.5
(20 - 0) = 20
(28)+(88-48)+(124-108) = 84
(48)+(108-68) = 88
66
4949