Professional Documents
Culture Documents
Basic Concepts
Scheduling Criteria
Scheduling Algorithms
Thread Scheduling
Multiple-Processor Scheduling
Algorithm Evaluation
5.2
Objectives
To introduce CPU scheduling, which is the basis for multiprogrammed operating systems
To discuss evaluation criteria for selecting a CPU-scheduling algorithm for a particular system
5.3
Basic Concepts
CPUI/O Burst Cycle Process execution consists of a cycle of CPU execution and I/O wait
5.4
5.5
5.6
CPU Scheduler
Selects from among the processes in ready queue, and allocates the CPU to one of them
2.
3.
4.
Terminates
5.7
Dispatcher
Dispatcher module gives control of the CPU to the process selected by the short-term scheduler; this
involves:
switching context
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
5.8
Scheduling Criteria
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)
5.9
Max throughput
5.10
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
24
P3
27
30
5.11
P2
P3
P1
30
5.12
Associate with each process the length of its next CPU burst
Use these lengths to schedule the process with the shortest time
SJF is optimal gives minimum average waiting time for a given set of processes
5.13
Example of SJF
ProcessArriva
l Time
Burst Time
P1
0.0
P2
2.0
P3
4.0
P4
5.0
P2
P3
P1
9
16
24
5.14
Can only estimate the length should be similar to the previous one
Can be done by using the length of previous CPU bursts, using exponential averaging
Commonly, set to
n =1 = t n + (1 ) n .
5.15
5.16
=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 -j +
+(1 - )n +1 0
Since both and (1 - ) are less than or equal to 1, each successive term has less weight than its
predecessor
5.17
Example of Shortest-remaining-time-first
Now we add the concepts of varying arrival times and preemption to the analysis
ProcessA
Burst Time
P1
P2
P3
P4
P3
P1
P4
P2
P1
10
17
26
5.18
Priority Scheduling
The CPU is allocated to the process with the highest priority (smallest integer highest priority)
Preemptive
Nonpreemptive
SJF is priority scheduling where priority is the inverse of predicted next CPU burst time
5.19
Priority
P1
10
P2
P3
P4
P5
P1
P5
P2
P3
16
P4
18
19
5.20
Each process gets a small unit of CPU time (time quantum q), usually 10-100 milliseconds. After this
time 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.
Performance
q large FIFO
q small q must be large with respect to context switch, otherwise overhead is too high
5.21
P1
0
Burst Time
24
3
3
P2
4
P3
7
P1
10
P1
14
P1
18
P1
22
P1
26
30
5.22
5.23
5.24
Multilevel Queue
foreground (interactive)
background (batch)
foreground RR
background FCFS
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
5.25
5.26
A process can move between the various queues; aging can be implemented this way
number of queues
method used to determine which queue a process will enter when that process needs service
5.27
Three queues:
Q2 FCFS
Scheduling
5.28
5.29
Thread Scheduling
Many-to-one and many-to-many models, thread library schedules user-level threads to run on LWP
Known as process-contention scope (PCS) since scheduling competition is within the process
Kernel thread scheduled onto available CPU is system-contention scope (SCS) competition among all
threads in system
5.30
Pthread Scheduling
5.31
5.32
5.33
Multiple-Processor Scheduling
Asymmetric multiprocessing only one processor accesses the system data structures, alleviating the
need for data sharing
Symmetric multiprocessing (SMP) each processor is self-scheduling, all processes in common ready
queue, or each has its own private queue of ready processes
Processor affinity process has affinity for processor on which it is currently running
soft affinity
hard affinity
5.34
5.35
Multicore Processors
Takes advantage of memory stall to make progress on another thread while memory retrieve
happens
5.36
5.37
5.38
Solaris scheduling
Windows XP scheduling
Linux scheduling
5.39
Solaris
Priority-based scheduling
Interactive
Real time
System
Fair Share
Fixed priority
5.40
5.41
Solaris Scheduling
5.42
Runs until (1) blocks, (2) uses time slice, (3) preempted by higher-priority thread
5.43
Windows Scheduling
Dispatcher is scheduler
Thread runs until (1) blocks, (2) uses time slice, (3) preempted by higher-priority thread
5.44
Win32 API identifies several priority classes to which a process can belong
REALTIME_PRIORITY_CLASS, HIGH_PRIORITY_CLASS,
ABOVE_NORMAL_PRIORITY_CLASS,NORMAL_PRIORITY_CLASS,
BELOW_NORMAL_PRIORITY_CLASS, IDLE_PRIORITY_CLASS
5.45
Windows XP Priorities
5.46
Linux Scheduling
5.47
5.48
5.49
5.50
Algorithm Evaluation
Deterministic modeling
Takes a particular predetermined workload and defines the performance of each algorithm for that
workload
5.51
Queueing Models
Describes the arrival of processes, and CPU and I/O bursts probabilistically
Computer system described as network of servers, each with queue of waiting processes
5.52
Littles Formula
Littles law in steady state, processes leaving queue must equal processes arriving, thus
n=xW
For example, if on average 7 processes arrive per second, and normally 14 processes in queue, then average wait
time per process = 2 seconds
5.53
Simulations
Clock is a variable
5.54
5.55
Implementation
Even simulations have limited accuracy
Environments vary
5.56
End of Chapter 5
5.08
5.58
In-5.7
5.59
In-5.8
5.60
In-5.9
5.61
Dispatch Latency
5.62
FIFO Queue is Used if There Are Multiple Threads With the Same Priority
5.63
2.
* Note the JVM Does Not Specify Whether Threads are Time-Sliced or Not
5.64
Time-Slicing
Since the JVM Doesnt 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
5.65
Thread Priorities
Priority
Comment
Thread.MIN_PRIORITY
Thread.MAX_PRIORITY
Thread.NORM_PRIORITY
5.66
Solaris 2 Scheduling
5.67