Upload
layne-farrin
View
249
Download
1
Tags:
Embed Size (px)
Citation preview
Dr. Kalpakis
CMSC 421, Operating Systems
http://www.csee.umbc.edu/~kalpakis/Courses/421
CPU Scheduling
CMSC 421
2
Outline
Basic Concepts
Scheduling Criteria
Scheduling Algorithms
Multiple-Processor Scheduling
Real-Time Scheduling
Algorithm Evaluation
CMSC 421
3
Basic Concepts
multiprogramming has been introduced in order to maximize
CPU utilization
CPU–I/O Burst Cycle
Process execution consists of a cycle of CPU execution and I/O wait.
CPU and I/O burst distribution
Can be viewed as a random variable
Can be characterized with an empirical and/or theoretical probability
distribution
CMSC 421
4
Alternating Sequence of CPU And I/O Bursts
CMSC 421
5
Histogram of CPU-burst Times
CMSC 421
6
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.
Once a process is given the CPU it holds it until it terminates or changes
state to waiting
All other scheduling is preemptive.
CMSC 421
7
Dispatcher
The Dispatcher module gives control of the CPU to the process
selected by the CPU (short-term) scheduler
The dispatcher’s function involves:
switching context
switching to user mode
jumping to the proper location in the user program to restart that
program
Dispatch latency
The time it takes for the dispatcher to stop one process and start running
running.
CMSC 421
8
Scheduling Algorithms
Before we look into scheduling algorithms need to set
Criteria (measures) and objectives that will be used in designing and
evaluating such algorithms
Scheduling algorithms should optimize some objectives derived
from certain criteria
Need to understand various properties of scheduling algorithms
so that we can choose an algorithm that is most suited to a
particular computing environment
CMSC 421
9
Scheduling Criteria
CPU utilization
Percent of time the CPU is busy executing processes
Throughput
number 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 (program) was submitted until the first response is produced,
Does not include output time
CMSC 421
10
Optimization Objectives
Maximize CPU utilization
Maximize throughput
Minimize the maximum turnaround time
Minimize average waiting time
Minimize average response time
Minimize the variance of response time
Etc
We will consider
Minimizing the average waiting time
CMSC 421
11
First-Come First-Served (FCFS) Scheduling
Process requesting the CPU first gets it first
Simple to implement with a single FIFO queue of ready
processes
Link their PCB’s into that queue
Non-preemptive scheduling algorithm
CMSC 421
12
FCFS Scheduling Example
Process Burst Time
P1 24
P2 3
P3 3
Suppose that the processes arrive at time 0 in the order: P1 , P2 , P3
The Gantt Chart for the schedule is:
Waiting time for P1 = 0; P2 = 24; P3 = 27
Average waiting time: (0 + 24 + 27)/3 = 17
P1 P2 P3
24 27 300
CMSC 421
13
FCFS Scheduling Example
Suppose that the processes arrive in the order P2 , P3 , P1 .
The Gantt chart for the schedule is:
Waiting time for P1 = 6; P2 = 0; P3 = 3
Average waiting time: (6 + 0 + 3)/3 = 3
Average waiting time depends on order of processes in FIFO queue
Convoy effect Arises when a number of short (I/O bound) processes wait behind a long (CPU bound) process
P1P3P2
63 300
CMSC 421
14
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:
Non-preemptive
once the CPU is 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 the remaining time
of the current executing process, preempt it.
This scheme is known as the Shortest-Remaining-Time-First (SRTF).
SJF is optimal
It gives the minimum average waiting time for a given set of processes.
CMSC 421
15
Process Arrival Time Burst Time
P1 0 7
P2 2 4
P3 4 1
P4 5 4
SJF (non-preemptive)
Average waiting time = (0 + 6 + 3 + 7)/4 =4
Non-Preemptive SJF Example
P1 P3 P2
73 160
P4
8 12
CMSC 421
16
Preemptive SJF Example
Process Arrival Time Burst Time
P1 0 7
P2 2 4
P3 4 1
P4 5 4
SJF (preemptive)
Average waiting time = (9 + 1 + 0 +2)/4 =3
P1 P3P2
42 110
P4
5 7
P2 P1
16
CMSC 421
17
Difficulties with SJF
Length of next CPU burst is generally not known ahead of time
Can only estimate the length of the next CPU burst
Need appropriate estimating functions
Can be done by using the length of previous CPU bursts, using
exponential averaging.
:Define 4.
10 , 3.
burst CPU next the for value predicted 2.
burst CPU of lenght actual 1.
1n
thn nt
.1 1 nnn t
CMSC 421
18
Prediction of the Length of the Next CPU Burst
CMSC 421
19
Examples of Exponential Averaging
=0n+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.
CMSC 421
20
Priority Scheduling
A priority number (integer) is associated with each process
The CPU is allocated to the process with the highest priority
Here, we use the convention that smallest integer highest priority.
It can be
Preemptive
Non-preemptive
SJF is a priority scheduling where priority is determined by the predicted
next CPU burst time.
Can cause Starvation
A low priority processes may never execute
Aging is a technique that can be used to avoid starvation
as time progresses increase the priority of processes waiting for the CPU
CMSC 421
21
Round Robin (RR) Scheduling
Each process gets a small unit of CPU time (time quantum or slice), usually 10-100 milliseconds.
After this time slice 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 chunks of at most q time units at once.
No process waits more than (n-1)q time units.
When deciding on the time slice need to consider the overhead due to the dispatcher
Performance characteristics
q large FIFO
q small q must be large with respect to context switch, otherwise overhead is too high.
CMSC 421
22
RR Scheduling Example with Time Quantum = 20
Process Burst Time
P1 53
P2 17
P3 68
P4 24
The Gantt chart is:
Typically, higher average turnaround time than SJF, but better response time.
P1 P2 P3 P4 P1 P3 P4 P1 P3 P3
0 20 37 57 77 97 117 121 134 154 162
CMSC 421
23
Time Quantum and Context Switch Time
CMSC 421
24
Turnaround Time Varies With The Time Quantum
CMSC 421
25
Multilevel Queue Scheduling
Ready queue is partitioned into separate queues
foreground (interactive)
background (batch)
Each queue has its own scheduling algorithm
foreground – RR
background – FCFS
CMSC 421
26
Multilevel Queue Scheduling
CMSC 421
27
Multilevel Queue Scheduling
Scheduling must be done between the queues.
Fixed priority scheduling
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
CMSC 421
28
Multilevel Feedback Queue Scheduling
A process can move between the various queues
aging can be implemented this way.
Multilevel-feedback-queue scheduler is defined by the
following parameters
number of queues
scheduling algorithms for each queue
method used to determine when to promote 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
CMSC 421
29
Multilevel Feedback Queue Scheduling Example
CMSC 421
30
Multilevel Feedback Queue Scheduling Example
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.
CMSC 421
31
Multiple-Processor Scheduling
CPU scheduling is more complex when multiple CPUs are available.
Homogeneous processors
All processors are identical within the multiprocessor system
Load sharing
Idle processors share the load of busy processors
Maintain a single ready queue shared among all the processors
Symmetric multiprocessing
Each processor schedules a process autonomously from the shared ready queue
Asymmetric multiprocessing
only one processor accesses the system data structures, alleviating the need for
data sharing.
CMSC 421
32
Real-Time Scheduling
Hard real-time systems
When it is required to complete a critical task within a guaranteed
amount of time
Soft real-time computing
When it is required that critical processes receive priority over less
fortunate ones.
For soft real-time scheduling
System must have priority scheduling
The dispatch latency must be small
Problem caused by the fact that many OSs wait for a context switch until
either a system call completes or an I/O blocks
CMSC 421
33
Keeping the Dispatch Latency Small
Introduce preemption points within the kernel
Where it is safe to preempt a system call by a higher priority process
Trouble is only few such points can be practically added
Make the entire kernel preemptive
Need to ensure that it is safe for a higher priority process to access
shared kernel data structures
Complex method that is widely used
What happens when a high priority process waits for lower
priority processes to finish using a shared kernel data structure
(priority inversion)?
Priority inheritance
CMSC 421
34
Dispatch Latency
CMSC 421
35
Evaluating Scheduling Algorithms
Deterministic modeling
take a particular predetermined workload and determine the performance
of each algorithm for that workload
Queueing Models
Use mathematical formulas to analyze the performance of algorithms
under some (simple and possible unrealistic) workloads
Simulation Models
Use probabilistic models of workloads
Use workloads captured in a running system (traces)
Implementation
CMSC 421
36
Queueing Models
Assuming that
Process inter-arrival times and CPU burst times are independent
identical exponentially distributed random variables
FCFS scheduling
timed turnarounmean theis T where
: LawsLittle'
system thein procs# mean theis )1/(
system thein procs n ofy probabilit theis )1(
nutilizatio (CPU)server mean theis /
/1][ where1][
/1][ where1][
TN
N
P
tEetP
tEetP
nn
cpuburstcpuburst
arrivalarrival
CMSC 421
37
Evaluation of CPU Scheduling Algorithms by Simulation
CMSC 421
38
Solaris 2 Scheduling
CMSC 421
39
Windows 2000 Priorities
CMSC 421
40
Linux Scheduling
Two algorithms: time-sharing and real-timeTime-sharing
Prioritized credit-based – process with most credits is scheduled nextCredit subtracted when timer interrupt occursWhen credit = 0, another process chosenWhen all processes have credit = 0, recrediting occurs
Based on factors including priority and history
Real-timeSoft real-timePosix.1b compliant – two classes
FCFS and RRHighest priority process always runs first
CMSC 421
41
The Relationship Between Priorities and Time-slice length
CMSC 421
42
List of Tasks Indexed According to Prorities