Transcript Ceng 334 - Operating Systems

Scheduling
• Scheduling is divided into various levels.
• These levels are defined by the location of
the processes
• A process can be
–
–
–
–
available to be executed by the processor
partially or fully in main memory
in secondary memory
is not started yet
CSE 331 Operating Systems Design
1
Types of Scheduling
• Long Term Scheduling (batch processing)
– The decision to add to the pool of processes to be
executed.
• Medium Term Scheduling (swapping)
– The decision to add to the process in main memory.
• Short Term Scheduling(CPU Scheduling)
– The decision as to which process will gain the
processor.
• I/O Scheduling
– The decision as to which process's I/O request shall be
handled by a device.
CSE 331 Operating Systems Design
2
CPU Scheduling
• Select process(es) to run on processor(s)
• Process state is changed from “ready” to
“running”
• The component of the OS which does the
scheduling is called the scheduler
CSE 331 Operating Systems Design
3
Basic Concepts (CPU Scheduling)
• Maximum CPU utilization obtained with
multiprogramming
• CPU–I/O Burst Cycle – Process execution
consists of a cycle of CPU execution and
I/O wait.
• CPU burst distribution
CSE 331 Operating Systems Design
4
Alternating Sequence of CPU And I/O Bursts
CSE 331 Operating Systems Design
5
Histogram of CPU-burst Times
CSE 331 Operating Systems Design
6
Types of CPU Scheduling
• A scheduling algorithm is NON-PREEMPTIVE
(run to completion) if the CPU cannot be taken
away by the OS.
• A scheduling algorithm is PREEMPTIVE if the
CPU can be taken away by the OS.
CSE 331 Operating Systems Design
7
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. Switches from running to waiting state.
2. Switches from running to ready state.
3. Switches from waiting to ready.
4. Terminates.
• Scheduling under 1 and 4 is nonpreemptive.
• All other scheduling is preemptive.
CSE 331 Operating Systems Design
8
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. (context switch
overhead)
CSE 331 Operating Systems Design
9
The Interrupting Clock- Timer
• The OS sets the interrupting clock to generate an
interrupt at some specified future time.
• This interrupt time is the process quantum(time
slice-ts, time quantum-tq).
• Provides reasonable response times and prevents
the system being held up by processes in infinite
loops.
CSE 331 Operating Systems Design
10
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
• 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)
CSE 331 Operating Systems Design
11
Optimization Criteria
• Fairness : each process should get a fair
share of the CPU
• Efficiency: keep CPU 100% utilized
• Response time : should be minimized for
interactive users
• Turnaround : minimize batch turnaround
times
• Throughput : maximize number of jobs
processed per hour
CSE 331 Operating Systems Design
12
User-Oriented, Performance Criteria
Criteria
Response Time
Turnaround Time
Deadlines
Aim
low response time,
maximum number of
interactive users
time between submission
and completion
maximize deadlines met
CSE 331 Operating Systems Design
13
System-oriented, Performance Criteria
Criteria
Aim
•Throughput
allow maximum number of jobs to complete
•Processor
maximize percentage of time processor is busy
utilization
•Overhead
minimize time processor busy executing OS
CSE 331 Operating Systems Design
14
System oriented, other criteria
Criteria
Aim
Fairness
treat processes the same avoid starvation
Enforcing Priorities
give preference to higher priority processes
Balancing Resources keep the system resources busy
CSE 331 Operating Systems Design
15
Important Factors
•
•
•
•
•
•
•
I/O / CPU boundedness of a process
Is the process interactive or batch?
Process priority
Page fault frequency (Virtual Memory )
Preemption frequency (time slice)
Execution time received
Execution time required to complete
CSE 331 Operating Systems Design
16
Popular research area in 1970’s..
Assumptions
• One program per user
• One thread per program
• Programs are independent
CSE 331 Operating Systems Design
17
Scheduling Algorithms
•
•
•
•
•
•
•
•
•
FCFS
-----------------------FCFS
Shortest Job First ------------------ SJF
Shortest Remaining Time
Highest Response Ratio Next
Round Robin -------------------------RR
Virtual Round Robin
Priority -------------------------------Priority
Priority Classes(Multilevel Queues)
Feedback Queues
CSE 331 Operating Systems Design
18
FCFS (First Come First Serve)
• 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-premptive
– Penalizes short and I/O-bound processes
CSE 331 Operating Systems Design
19
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:
P1
0
P2
24
P3
27
30
• Waiting time for P1 = 0; P2 = 24; P3 = 27
• Average waiting time: (0 + 24 + 27)/3 = 17
CSE 331 Operating Systems Design
20
FCFS Scheduling (Cont.)
Suppose that the processes arrive in the order
P2 , P3 , P1 .
• The Gantt chart for the schedule is:
P2
0
P3
3
P1
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
CSE 331 Operating Systems Design
21
Approximating Load
•
•
•
•
•
•
•
Let λ = mean arrival rate
So 1/ λ = mean time between arrivals
And µ = mean service rate
So 1/ µ = mean service time (avg t(pi))
CPU busy = ρ = λ * 1/ µ = λ / µ
Notice must have λ / µ (i.e., ρ < 1)
What if ρ approaches 1?
CSE 331 Operating Systems Design
22
Predicting Wait Time in FCFS
• In FCFS, when a process arrives, all in
ready list will be processed before this job
• Let µ be the service rate
• Let L be the ready list length
Wavg(p) = L*1/ µ + 0.5* 1/ µ = L/ µ +1/(2 µ )
Compare predicted wait with actual in earlier examples
CSE 331 Operating Systems Design
23
Shortest-Job-First (SJF)
• Sometimes known as Shortest Process Next
(SPN)
• Implementation:
–The process with the shortest expected
execution time is given priority on the
processor
CSE 331 Operating Systems Design
24
Example of Non-Preemptive SJF
0
Process
Arrival Time
Burst Time
P1
P2
P3
P4
0.0
2.0
4.0
5.0
7
4
1
4
P1
P3
3
7
P2
8
P4
12
16
• SJF (non-preemptive)
• Average waiting time = (0 + 6 + 3 + 7)/4 = 4
CSE 331 Operating Systems Design
25
SJF-continued
• Characteristics:
– Non-premptive
– Reduces average waiting time over FIFO
– Always produces the minimum average
turnaround time
– Must know how long a process will run
– Possible user abuse
– Suitable for batch environments. Not useful in a
timesharing environment
CSE 331 Operating Systems Design
26
Shortest Remaining Time (SRT)
• Preemptive counterpart of SPN
• Implementation:
–Process with the smallest estimated runtime to completion is run next
–A running process may be preempted by a
new process with a shorter estimate runtime
CSE 331 Operating Systems Design
27
Example of Preemptive SJF
Process
Arrival Time
Burst Time
P1
P2
P3
P4
0.0
2.0
4.0
5.0
7
4
1
4
P1
0
P2
2
P3
4
P2
5
P4
7
P1
11
16
• SJF (preemptive)
• Average waiting time = (9 + 1 + 0 +2)/4 =3
CSE 331 Operating Systems Design
28
SRT-continued
• Characteristics:
– Still requires estimates of the future
– Higher overhead than SJF
– No additional interrupts are generated as
in Round Robin
– Elapsed service times must be recorded
CSE 331 Operating Systems Design
29
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
 (1 -  ) .
 t
CSE 331 Operating Systems Design
n
n
30
Prediction of the Length of the Next CPU Burst
CSE 331 Operating Systems Design
31
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.
CSE 331 Operating Systems Design
32
Highest Response Ratio Next (HRRN)
• How do you get around the problem of Indefinite
postponement?
• Implementation:
– Once a job gets the CPU, it runs to completion
– The priority of a job is a function of the job's
service time and the time it has been waiting for
service
priority = (time waiting + service time) / service
time
CSE 331 Operating Systems Design
33
• Characteristics:
–Nonpremptive
–Shorter jobs still get preference over
longer jobs
–However aging ensures long jobs will
eventually gain the processor
–Estimation still involved
CSE 331 Operating Systems Design
34
Round Robin (RR)
• Implementation:
– Processes are dispatched FIFO. But are given a
fixed time on the CPU (quantum - time slice).
• Characteristics:
– Preemptive
– Effective in time sharing environments
– Penalizes I/O bound processes
CSE 331 Operating Systems Design
35
Quantum Size
• Some Options:
– Large or small quantum
– Fixed or variable quantum
– Same for everyone or different
– If quantum is to large RR degenerates into FCFS
– If quantum is to small context switching becomes
the primary job being executed
• A good guide is: quantum should be slightly larger
than the time required for a typical interaction
(overhead 10%)
For 100ms ts - context switch time < 10ms
CSE 331 Operating Systems Design
36
Example of RR with Time Quantum = 20
Process
Burst Time
P1
P2
P3
P4
53
17
68
24
• The Gantt chart is:
P1
0
P2
20
37
P3
P4
57
P1
77
P3
97 117
P4
P1
P3
P3
121 134 154 162
• Typically, higher average turnaround than SJF, but
better response.
CSE 331 Operating Systems Design
37
Time Quantum and Context Switch Time
CSE 331 Operating Systems Design
38
Turnaround Time Varies With The Time Quantum
CSE 331 Operating Systems Design
39
Virtual Round Robin (VRR)
• A modification to the RR algorithm to remove
the bias towards CPU bound processes.
• Implementation:
– Two “ready” queues, one called an AUX
queue for storing “completed” IO processes
– AUX queue has priority over READY
queue
– IO processes only runs for remaining time
• Characteristics:
– Performance studies indicate fairer than RR
CSE 331 Operating Systems Design
40
Priority
• Implementation:
– Each process is assigned a priority and the
scheduler always selects the highest priority
process first
• Characteristics:
– High priority processes may run indefinitely, so
decrease the priority of these processes at
regular intervals
– Assign high priority to system processes with
known characteristics such as being I/O bound
CSE 331 Operating Systems Design
41
Priority Classes
Priority Class 4
Highest
Priority Class 3
Priority Class 2
Priority Class 1
CSE 331 Operating Systems Design
Lowest
42
• Implementation:
– Processes are grouped into priority classes
– Round Robin is used within a class
– When selecting process start with the highest
class. If the class is empty, use a lower class
• Characteristics:
– If priorities are not adjusted from time to time,
lower classes may starve to death
CSE 331 Operating Systems Design
43
Multilevel Queue
• Ready queue is partitioned into separate queues:
foreground (interactive)
background (batch)
• Each queue has its own scheduling algorithm,
foreground – RR
background – FCFS
• Scheduling must be done between the queues.
– Fixed priority scheduling; (i.e., serve all from
foreground then from background). Possibility of
starvation.
– Time slice – 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
CSE 331 Operating Systems Design
44
Multilevel Queue Scheduling
CSE 331 Operating Systems Design
45
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
CSE 331 Operating Systems Design
46
Example of Multilevel Feedback Queue
• Three queues:
– Q0 – time quantum 8 milliseconds
– Q1 – time quantum 16 milliseconds
– Q2 – FCFS
• 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.
– 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.
CSE 331 Operating Systems Design
47
Multilevel Feedback Queues
CSE 331 Operating Systems Design
48
• I/O processes:
– If the job requires I/O before quantum
expiration it leaves the network and comes
back at the same level queue
• CPU bound processes:
– If the quantum expires first, the process is
placed on the next lower queue
– This continues until it reaches the bottom
queue
CSE 331 Operating Systems Design
49
• Dispatching:
– A process is only placed on the CPU if all
higher level queues are empty
– A running process is preempted by a
process arriving in a higher queue
– Processes from lower level queues receive a
larger quantum
CSE 331 Operating Systems Design
50
Summary:
A CPU Scheduling Mechanism Should
• Favour short jobs
• Favour I/O bound jobs to get good I/O
device utilization
• Determine the nature of a job and schedule
accordingly
CSE 331 Operating Systems Design
51