operating system examples - scheduling. references r silberschatz et al, chapter 5.6, chapter...
TRANSCRIPT
References
Silberschatz et al, Chapter 5.6, Chapter 22.3.22 (Windows 7)
http://linux-bangalore.org/blug/meetings/200401/scheduler-2.6.pdf
Note: Process/Thread
A unit of execution is a process Processes can create a unit of execution
called a thread Threads share data with processes Operating systems schedule threads in the
same way processes are scheduled We will discuss threads in much greater
detail later in the course
Solaris Solaris uses priority-
based scheduling Each process
belongs to one of six classes Time sharing Interactive Real time System File share Fixed priority
Default scheduling class time sharing
Within each class: Different priorities Different scheduling
algorithms Priority levels from 0
to 169
Priorities
Interrupt Real-time class
Highest priority Guaranteed response time Kernel processes (very few) assigned this
class System class
Kernel processes are assigned to this class e.g., scheduler
Priorities are static
Priorities
Time-sharing Processes can have their priorities adjusted
Fixed-priority Introduced in Solaris 9 No dynamic adjustment of priorities
Fair-share Uses CPU shares instead of priorities A share is an indicator of entitlement
Real-Time Scheduling
Real-time priority queues can be configured to operate with a FIFO-strategy or a Round Robin strategy
Real-time processes can preempt running processes that have lower priority Tend to be few real-time processes
Time Sharing Scheduling Algorithm
Default priority for a user process is time sharing
Priorities are dynamic Use of a multilevel feedback queue
Each queue represents a different priority level
Time slices (quantum) are associated with a priority queue
Higher priorities smaller time slice
Time Sharing Scheduling Algorithm
Solaris uses a dispatch table This is used to assign a new priority to a
process. Two cases: Time quantum expired without blocking
Could be a CPU intensive process Process blocked before time quantum
expired This new priority will be used to
determine the process in a priority queue when the process returns to a READY state
Solaris Dispatch Table Priority: A higher number indicates a
higher priority Time quantum: There is an inverse
relationship between priorities and time quanta
Time quantum expired: The new priority of a process that has used its entire time quantum without blocking
Return from sleep: The priority of a process that is returning from the blocked state (such as waiting for I/O)
Scheduling Algorithm
Time sharing scheduling algorithm If a priority has used its entire time
quantum without blocking its priority is changed (with one exception)
The priority of a priority that is returning from sleeping (e.g. waiting for I/O) has its priority increased• This allows for better support of interactive
processes
Interactive Processes
Interactive processes (e.g., window managers) typically have higher priority (good response time)
CPU-bound processes have lower priority (good throughput)
Priorities Similar to that used in Windows XP The scheduler is called a dispatcher 32 priorities Priorities are divided into two classes:
User class: priorities 1 to 15 Real-time class: priorities 16 to 31
Priority 0 is used for memory management processes
There is a queue for each priority
Selecting a Process The dispatcher traverses the set of
queues from highest to lowest until it finds a process that is ready to run
If there are no processes ready to run the dispatcher executes the idle process
Priority of a preempted process may be modified before being returned to a ready state
Round robin
Adjusting Priority If process was in user class
Time quantum expires: • If process is in the user class the priority is
lowered Process switches from blocked to running:
• Priority is increased• The amount depends on what the process was
doing• Keyboard I/O gets a large increase while disk I/O
gets a moderate increase
Some processes always have a low priority e.g., disk fragmenter
Adjusting Priority The priority of a process cannot be
lowered passed the base priority (lower threshold value) of the process
Windows 7 distinguishes between the foreground process that is currently selected on the screen and the background processes that are not currently selected Tends to give good response times to
interactive processes that are using the mouse and windows
Linux
Used for both servers and workstations Linux provides flexibility so that
performance is optimized
Linux Scheduling Goals
Implement scheduling algorithms in O(1) time.
Provide good interactive performance. Optimize for the common case of only one
or two runnable processes, yet scale well to multiple processors, each with many processes.
Linux uses the term task to refer to a process/thread
Linux priority levels are on the next slide
25
Priorities
Priorities 0-99 for real-time processes
Priorities 100-139 for normal (user) processes
Linux Scheduling
A process is considered for execution on the CPU as long as it has time remaining in its time slice (quantum)
When a task has exhausted its time slice, it is considered expired and is not eligible for execution again until all other tasks have all exhausted their time slice
Linux Data Structures The kernel maintains a list of all
runnable tasks in a runqueue data structure
A runqueue consists of two priority arrays: Active: Contains all tasks with time
remaining in their time slices Expired: Contains all expired tasks
The active, expired queues are indexed according to priority
Linux Scheduling How is a process selected for execution?
The scheduler finds the highest-priority queue with a runnable process
Finds the first process on the queue Determine its quantum size (more later)
What happens to a running process that does not complete its time quantum? When that process returns to the ready
state it goes into the active array
Linux Scheduling When there are no more processes in
the active array, the expired array becomes the active array and the active array becomes the expired array.
A process’s priority (queue) is recalculated when the process has exhausted its time quantum and is to be moved to the expired array
To Discuss
Linux Efficiency Calculating time quantum using static
priorities Determining the queue that a process
should be placed using dynamic priority
Linux Efficiency
We will now discuss efficiency. Choice of next process to run:
Process with the highest priority A bitmap is created such that there is 1
bit for every priority level. 140 priority levels Bitmap size:
• 140 bits/32 bits per word = 4.375 words = 5 words
If a running process exists at a level with quantum left, the corresponding bit is true
Linux Efficiency
If a priority N has a process that can be run, bitmap[N] = 1
The first bit position in bitmap that is 1 represents the priority level from which a process is chosen
A priority level is a queue Pick the first process
Linux Efficiency
Find the first bit with a 1 Hardware instruction to find the first 1-bit
• bsfl on Intel Time depends on the number of priority
levels, not the number of processes
Linux Efficiency
There are pointers to the expired and active arrays
Making the expired array the active array requires update of the pointers Can be done quickly
No need for an explicit aging mechanism
Scheduling Components
Scheduler chooses a process based on dynamic priority.
Dynamic priority is a function of Static priority and bonus
Bonus is derived from sleep average Now to explain this
Static Priorities Each process has a static priority (SP)
Value is between 0 and 139
Real-time processes have a static priority between 0 and 99
All other processes (referred to as conventional) are assigned a static priority between 100-139
Static Priorities The static priority is set based on the
nice value Range of nice values: [-20,20] By default 0
Mapping of nice values to static priorities 0 maps to 120 -20 maps to 100 20 maps to 140
Static Priorities
Base time quantum: The time quantum assigned by the scheduler to a process if it has exhausted its previous time quantum If (SP < 120):Base time quantum = (140-
SP)* 20 If (SP ≥ 120):Base time quantum = (140-
SP)*5
Typical Quanta
Priority Static Priority
Quantum
Highest 100 800 ms
High 110 600 ms
Normal 120 100 ms
Low 130 50 ms
Lowest 139 5 ms
Dynamic Priority
Besides a static priority, a user process also has a dynamic priority Ranges from 100 (highest priority) to 139
(lowest priority) The dynamic priority is the number actually
used by the scheduler when selecting the new process to run. • This number is the queue
Adjusting Priorities
Dynamic priority (DP) is calculated from static priority (SP) and bonus value DP = max(100, min(SP-bonus+5,139))
The bonus is based on average sleep time Measure of interactiveness
Calculating Sleep Time The scheduler keeps track of the
average amount of time a task sleeps vs average amount of time task uses CPU Use the sleep_avg variable
When a process wakes the time spent sleeping is added to its sleep_avg
When a process is switched out, the run time is subtracted from sleep_avg
Calculating Sleep Time Sleep ratio
Mostly sleeping: I/O bound Mostly running: CPU bound
sleep_avg scaled to a bonus value
Sleep Time and Bonus Values
Sleep Time Bonus>=0 but < 100 ms 0
>= 100 ms but < 200 ms 1
>=200 ms but < 300 ms 2
>=300 ms but < 400 ms 3
>=400 ms but < 500 ms 4
>=500 ms but < 600 ms 5
>=600 ms but < 700 ms 6
>=700 ms but < 800 ms 7
>= 800 ms but < 900 ms 8
>=900 ms but < 1000 ms 9
1 second 10
Bonus and Dynamic Priority
Dynamic priority (DP) is calculated from static priority (SP) and bonus DP = max(100, min(SP-bonus+5,139))
Bonus: 0-10 <5: penalty
• Less sleeping >5: premium
• More sleeping (highly interactive)
The higher the bonus the task is getting and the higher its static priority, the more likely it is to be considered interactive
Using Quanta Assume a process has consumed its
quanta (time slice) Check interactive status:
If non-interactive, put it aside on the expired array
If interactive, put it at the end of the active array
Using Quanta
Exceptions to putting on higher-priority array: If higher-priority process is on expired list If expired task has been waiting more than
some specified amount of time If there’s nothing else at that priority, it
will run again immediately Of course, by running so much, its
bonus will go down, and so will its priority and its interactive status
MAC OS X
Based on MACH and Unix BSD Priorities are categorized into priority
bands Normal: Applications System high priority: Processes with higher
priority then Normal Kernel mode: Reserved for kernel processes Real-time: For processes that must be
guaranteed a slice of CPU time by a particular deadline
MAC OS X
Priorities change dynamically Based on wait time and amount of time
that the process has had the processor Stay within the same priority band
Reschedules every tenth of a second and recomputes priorities once every second
Prrocess will relinquish CPU after time quantum or when it must wait for an I/O completion
Feedback prevents starvation
Android
For mobile devices Today it is the most commonly used
platform Uses Linux for device managers,
memory management, process management