Chapter 5: CPU Scheduling

Chapter 5: CPU SchedulingChapter 5: CPU Scheduling

5.2 Silberschatz, Galvin and Gagne ©2005

Operating System Concepts

Chapter 5: ObjectivesChapter 5: Objectives

Understand Scheduling Criteria Scheduling Algorithms Multiple-Processor Scheduling



Basic ConceptsBasic Concepts

Maximum CPU utilization obtained with multiprogramming

CPU–I/O Burst Cycle Process execution consists of

a cycle of CPU execution and I/O wait

How long is the CPU burst?



CPU Burst DistributionCPU Burst Distribution

CPU bursts vary greatly from process to process and from computer to computer

But, in general, they tend to have the following distribution (expo)

Few long bursts

Many short bursts



CPU SchedulerCPU Scheduler Selects one process from ready queue to run on CPU Scheduling can be

Nonpreemptive Once a process is allocated the CPU, it does not leave

unless:

1. it has to wait, e.g., for I/O request or for a child to terminate

2. it terminates Preemptive

OS can force (preempt) a process from CPU at anytime – Say, to allocate CPU to another higher-priority

process Which is harder to implement? and why?

Preemptive is harder: Need to maintain consistency of data shared between processes, and more importantly, kernel data structures (e.g., I/O queues)

– Think of a preemption while kernel is executing a sys call on behalf of a process (many OSs, wait for sys call to finish)



DispatcherDispatcher

Scheduler: selects one process to run on CPU Dispatcher: allocates CPU to the selected process,

which involves: switching context switching to user mode jumping to the proper location (in the selected

process) and restarting it Dispatch latency – time it takes for the dispatcher

to stop one process and start another running

How does scheduler select a process to run?



Scheduling CriteriaScheduling Criteria

CPU utilization – keep the CPU as busy as possible Maximize

Throughput – # of processes that complete their execution per time unit Maximize

Turnaround time – amount of time to execute a particular process (time from submission to termination) Minimize

Waiting time – amount of time a process has been waiting in the ready queue Minimize

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



Scheduling AlgorithmsScheduling Algorithms

First Come, First Served Shortest Job First Priority Round Robin Multilevel queues

Note: A process may have many CPU bursts, but in the examples we show only one for simplicity



First-Come, First-Served (FCFS) First-Come, First-Served (FCFS) SchedulingScheduling

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:

Waiting time for P1 = 0; P2 = 24; P3 = 27

Average waiting time: (0 + 24 + 27)/3 = 17

P1 P2 P3

24 27 300



FCFS Scheduling (Cont.)FCFS Scheduling (Cont.)

Suppose that the processes arrive in the order

P2 , P3 , P1

3, 3, 24

The Gantt chart for the schedule is:

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

P1P3P2

63 300



Shortest-Job-First (SJF) Shortest-Job-First (SJF) SchedulingScheduling

Associate with each process the length of its next CPU burst. Use these lengths to schedule the process with the shortest time

Two schemes: nonpreemptive – once CPU 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 remaining time of current executing process, preempt. This scheme is know as the Shortest-Remaining-Time-First (SRTF)

SJF is optimal – gives minimum average waiting time for a given set of processes



Process Arrival Time Burst Time

P1 0.0 7

P2 2.0 4

P3 4.0 1

P4 5.0 4

SJF (non-preemptive)

Average waiting time = (0 + 6 + 3 + 7)/4 = 4

Example of Non-Preemptive SJFExample of Non-Preemptive SJF

P1 P3 P2

73 160

P4

8 12



Example of Preemptive SJFExample of Preemptive SJF

Process Arrival Time Burst Time

P1 0.0 7

P2 2.0 4

P3 4.0 1

P4 5.0 4

SJF (preemptive, SRJF)

Average waiting time = (9 + 1 + 0 +2)/4 = 3

P1 P3P2

42 110

P4

5 7

P2 P1

16



Determining Length of Next CPU Determining Length of Next CPU BurstBurst

Can only estimate the length 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.

1

≤≤=

=

+

αατ n

thn nt

€

τ n+1 =α tn + 1−α( )τ n



Exponential AveragingExponential Averaging

If we expand the formula, we get:

τn+1 = α tn + α (1 - α) tn -1 + α (1 - α )2 tn -2 + … + (1 - α )n +1 τ0

Since both α and (1 - α) are less than or equal to 1, each successive term has less weight than its predecessor

Examples:

α = 0 ==> τn+1 = τn ==> Last CPU burst does not count (transient value)

α =1 ==> τn+1 = α tn ==> Only last CPU burst counts (history is stale)



Prediction CPU Burst Lengths: Expo Prediction CPU Burst Lengths: Expo Average Average

Assume α = 0.5, τ0 = 10



Priority SchedulingPriority Scheduling

A priority number (integer) is associated with each process

The CPU is allocated to the process with the highest priority (smallest integer highest priority) Preemptive nonpreemptive

SJF is a priority scheduling where priority is the predicted next CPU burst time

Problem Starvation – low priority processes may never execute

Solution Aging – as time progresses increase the priority of the process

Aging: increase the priority of a process as it waits in the system



Round Robin (RR)Round Robin (RR)

Each process gets a small unit of CPU time (time quantum), 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 FCFS q small q must be large with respect to

context switch, otherwise overhead is too high



Example of RR with Time Quantum Example of RR with Time Quantum = 20= 20

Process Burst Time

P1 53

P2 17

P3 68

P4 24 The Gantt chart is:

Typically, higher average turnaround than SJF, but better response

P1 P2 P3 P4 P1 P3 P4 P1 P3 P3

0 20 37 57 77 97 117 121 134 154 162



Time Quantum and Context Switch Time Quantum and Context Switch TimeTime

Smaller q more responsive but more context switches (overhead)



Turnaround Time Varies With The Time Turnaround Time Varies With The Time QuantumQuantum

Turnaround time varies with quantum, then stabilizes Rule of thumb for good performance:

80% of CPU bursts should be shorter than time quantum



Multilevel QueueMultilevel 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; e.g., 80% to foreground in RR 20% to background in FCFS



Multilevel Queue SchedulingMultilevel Queue Scheduling



Multilevel Feedback QueueMultilevel Feedback Queue

A process can move between 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



Example of Multilevel Feedback Example of Multilevel Feedback QueueQueue

Three queues:

Q0 – RR with time quantum 8 milliseconds

Q1 – RR 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



Multilevel Feedback QueuesMultilevel Feedback Queues

Notes: Short processes get served faster (higher prio) more

responsive Long processes (CPU bound) sink to bottom served FCFS

more throughput



Multiple-Processor SchedulingMultiple-Processor Scheduling

Multiple processors ==> divide load among them More complex than single CPU scheduling

How to divide load? Asymmetric multiprocessor

One master processor does the scheduling for others

Symmetric multiprocessor (SMP) Each processor runs its own scheduler One common ready queue for all processors, or one ready queue for each

Win XP, Linux, Solaris, Mac OS X support SMP



SMP IssuesSMP Issues Processor affinity

When a process runs on a processor, some data is cached in that processor’s cache

A process migrates to another processor ==> Cache of new processor has to be re-populated Cache of old processor has to be invalidated ==> performance penalty

Load balancing One processor has too much load and another is idle Balance load using

Push migration: A specific task periodically checks load on all processors and evenly distributes it by moving (pushing) tasks

Pull migration: Idle processor pulls a waiting task from a busy processor

Some systems (e.g., Linux) implement both Tradeoff between load balancing and processor affinity: what

would you do? May be, invoke load balancer when imbalance exceeds a

threshold



Real-time SchedulingReal-time Scheduling

Hard-real time systems A task must be finished within a deadline Ex: Control of spacecraft

Soft-real time systems A task is given higher priority over others Ex: Multimedia systems



Operating System ExamplesOperating System Examples

Windows XP scheduling

Linux scheduling



Windows XP Scheduler Windows XP Scheduler Priority-based, preemptive scheduler

The highest-priority thread will always run 32 levels of priorities, each has a separate queue Scheduler traverses queues from highest to lowest

till it finds a thread that is ready to run Priorities are divided into classes, each has

several relative priorities



Windows XP Scheduler (cont’d)Windows XP Scheduler (cont’d) Real-time class (fixed): Levels 16 to 31 Other classes (variable): Levels 1 to 15

Priority may change (decrease or increase) Priority decreases

After thread’s quantum time runs out but never goes below the base (normal) value of its class

Limit CPU consumption of CPU-bound threads Priority increases

After a thread is released from a wait operation Bigger increase if thread was waiting for mouse

or keyboard Moderate increase if it was waiting for disk Also, active window gets a priority boost Yield good response time



Linux SchedulerLinux Scheduler Priority-based, preemptive scheduler with two separate ranges

Real-time: 0 to 99 Nice: 100 to 140 (from -20 to 19) Higher priority tasks get larger quanta (unlike Win XP, Solaris)



Linux Scheduler (cont’d)Linux Scheduler (cont’d)

A task is initially assigned a time slice (quantum) Runqueue has two arrays: active and expired A runnable task is eligible for CPU if it still has

time left in its time slice If the time slice runs out, the task is moved to the

expired array When there are no tasks in the active array, the

expired array becomes the active array and vice versa (change of pointers)



Algorithm EvaluationAlgorithm Evaluation

Deterministic modeling Takes a particular predetermined workload and

defines the performance of each algorithm for that workload

Not general Queuing models

Use queuing theory to analyze algorithms Many (unrealistic) assumptions to facilitate

analysis Simulation

Build a simulator and test with synthetic workload (e.g., generated randomly), or Traces collected from running systems

Implementation Code it up and test!



SummarySummary Process execution: cycle of CPU bursts and I/O bursts

CPU bursts lengths: many short bursts, and few long ones

Scheduler selects one process from ready queue Dispatcher performs the switching

Scheduling criteria (usually conflicting) CPU utilization, waiting time, response time,

throughput, … Scheduling Algorithms

FCFS, SJF, Priority, RR, Multilevel Queues, … Multiprocessor Scheduling

Processor affinity vs. load balancing Evaluation of Algorithms

Modeling, simulation, implementation Examples

Win XP, Linux

Chapter 5: CPU Scheduling

Documents

Transcript of Chapter 5: CPU Scheduling