Operating System Examples - Scheduling

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 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

Priorities Interrupt Real-time class System 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 Fixed-priority Fair-share 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 For time-sharing & Interactive processes

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)

Windows 7

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

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

Priorities and Time-slice length Priority Levels Priorities and Time-slice length

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 Data Structures List of Tasks Indexed According to Priorities

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 until arrays are changed.

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 until arrays are changed.

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 If SP = 100 BTQ is (140-100)*20 = 40*20 = 800 If SP = 110 BTQ is (140-110)*20 = 30*20 = 600 If SP = 120 BTQ is (140-120)*5 = 20*5 = 100 If SP=130 BTQ is (140-130)*5 = 10*5 = 50 If SP=139 BTW is (140-139)*5 = 1*5 = 5 l arrays are changed.

Typical Quanta Priority Static Priority Quantum Highest 100 800 ms 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 >=0 but < 100 ms >= 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

Other

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

Summary We have examined scheduling in several contemporary operating systems