Chapter 6 CPU Scheduling

(1)

Chapter 6 CPU Scheduling

(2)

CPU Scheduling

Objective:

Basic Scheduling Concepts

CPU Scheduling Algorithms

Why Multiprogramming?

Maximize CPU/Resources Utilization (Based on Some Criteria)

CPU Scheduling

Process Execution

CPU-bound programs tend to have a few very long CPU bursts.

IO-bound programs tend to have may very short CPU bursts.

CPU-Burst

I/O-Burst New

Terminate

(3)

CPU Scheduling

The distribution can help in selecting an appropriate CPU-scheduling algorithms

20 60 100 120

8 16 24

Burst Duration (ms)

frequency

CPU Scheduling

CPU Scheduler – The Selection of Process for Execution

A short-term scheduler New

Ready Running

Terminated

Waiting dispatched

(4)

CPU Scheduling

Nonpreemptive Scheduling

A running process keeps CPU until it volunteers to release CPU

Advantage

Easy to implement (at the cost of better resource sharing)

E.g., Windows 3.1

CPU Scheduling

Preemptive Scheduling

Beside the instances for non-preemptive scheduling, CPU scheduling occurs whenever some process becomes ready or the running process leaves the running state!

Issues involved:

Protection of Resources such as I/O queues

Synchronization

E.g., Interrupts and System calls

(5)

CPU Scheduling

Dispatcher

Functionality:

Switching context

Switching to user mode

Restarting a user program

Dispatch Latency:

Start a process Must be fast

Stop a process

Scheduling Criteria

Why?

Different scheduling algorithms may favor one class of processes over another!

Criteria

CPU Utilization

Throughput

Turnaround Time

Waiting Time

Response Time

(6)

Scheduling Criteria

How to Measure the Performance of CPU Scheduling Algorithm?

Optimization of what?

General Consideration

Average Measure

Minimum or Maximum Values

Variance Æ Predictable Behavior

Scheduling Algorithms

First-Come, First-Served Scheduling (FIFO)

Shortest-Job-First Scheduling (SJF)

Priority Scheduling

Round-Robin Scheduling (RR)

Multilevel Queue Scheduling

Multilevel Feedback Queue Scheduling

Multiple-Processor Scheduling

(7)

First-Come, First-Served Scheduling (FCFS)

The process which requests the CPU first is allocated the CPU

Properties:

Non-preemptive scheduling

CPU might be hold for an extended period.

CPU request

A FIFO ready queue dispatched

First-Come, First-Served Scheduling (FCFS)

Example

Process P1 P2 P3

CPU Burst Time 24

3 3

P1 P2 P3

0 24 27 30

Average waiting time

= (0+24+27)/3 = 17

P2 P3 P1

0 3 6 30

= (6+0+3)/3 = 3

*The average waiting time is highly affected by process CPU burst times !

Gnatt Chart

(8)

Example: Convey Effect

One CPU-bound process + many I/O-bound processes

First-Come, First-Served Scheduling (FCFS)

CPU

ready queue

I/O device

idle

All other processes wait for it to get off the CPU!

Shortest-Job-First Scheduling (SJF)

Non-Preemptive SJF

Shortest next CPU burst first

process P1 P2 P3 P4

CPU burst time 6

8 7 3

P4 P1 P3 P2

0 3 9 16 24

(9)

Shortest-Job-First Scheduling (SJF)

Nonpreemptive SJF is optimal when processes are all ready at time 0

The minimum average waiting time!

Prediction of the next CPU burst time?

Long-Term Scheduler

A specified amount at its submission time

Short-Term Scheduler

Exponential average

τ

_n+1

= α t

_n

+ (1-α) τ

_n

Shortest-Job-First Scheduling (SJF)

Preemptive SJF

Shortest-remaining-time-first Process

P1 P2 P3 P4

CPU Burst Time 8

4 9 5

Arrival Time 0 1 2 3

P1 P2 P4 P1 P3

0 1 5 10 17 26

Average Waiting Time = ((10-1) + (1-1) + (17-2) + (5-3))/4 = 26/4

= 6.5

(10)

Shortest-Job-First Scheduling (SJF)

Preemptive or Non-preemptive?

Criteria such as AWT (Average Waiting Time)

0 10

1 10 11

Non-preemptive AWT = (0+(10-1))/2

= 9/2 = 4.5

or 0

1 2

11 Preemptive AWT

= ((2-1)+0) = 0.5

* Context switching cost ~ modeling & analysis

Priority Scheduling

CPU is assigned to the process with the highest priority – A

framework for various scheduling algorithms:

FCFS: Equal-Priority with Tie- Breaking by FCFS

SFJ: Priority = 1 / next CPU burst length

(11)

Priority Scheduling

Process P1 P2 P3 P4 P5

CPU Burst Time 10

1 2 1 5

Arrival Time 3 1 3 4 2 Gantt Graph

P2 P5 P1 P3 P4

0 1 6 16 18 19

Priority Scheduling

Priority Assignment

Internally defined – use some

measurable quality, such as the # of open files,

Externally defined – set by criteria external to the OS, such as the criticality levels of jobs.

Average I/O Burst Average I/O Burst

(12)

Priority Scheduling

Preemptive or Non-Preemptive?

Preemptive scheduling – CPU scheduling is invoked whenever a process arrives at the ready queue, or the running process relinquishes the CPU.

Non-preemptive scheduling – CPU scheduling is invoked only when the running process relinquishes the CPU.

Priority Scheduling

Major Problem

Indefinite Blocking (/Starvation)

Low-priority processes could starve to death!

A Solution: Aging

A technique that increase the priority of processes waiting in the system for a long time.

(13)

Round-Robin Scheduling (RR)

RR is similar to FCFS except that

preemption is added to switch between processes.

Goal: Fairness – Time Sharing

ready running

Interrupt at every time quantum (time slice)

FIFO…

CPU

The quantum is used up!

New process

Round-Robin Scheduling (RR)

Process P1 P2 P3

CPU Burst Time 24

3 3

Time slice = 4

P1 P2 P3 P1 P1 P1 P1 P1 0 4 7 10 14 18 22 26 30

AWT = ((10-4) + (4-0) + (7-0))/3

= 17/3 = 5.66

(14)

Round-Robin Scheduling (RR)

Service Size and Interval

Time quantum = q Æ Service interval <= (n- 1)*q if n processes are ready

IF q = ∞, then RR Æ FCFS

IF q = ε, then RR Æ processor sharing. The

# of context switchings increases!

0 10

0 6 10

0 10

process quantum 12

6 1

context switch # 0

1 9

If context switch cost

time quantum = 10% => 1/11 of CPU is wasted!

Round-Robin Scheduling (RR)

Turnaround Time

0 10 20 30

process (10ms) P1 P2

P3 20 30

10 20

0 10

quantum = 10 quantum = 1

Average Turnaround Time

= (10+20+30)/3 = 20

ATT = (28+29+30)/3 = 29

=> 80% CPU Burst < time slice

(15)

Multilevel Queue Scheduling

Partition the ready queue into several separate queues =>

processes can be classified into different groups and permanently assigned to one queue.

…

Process Group 1 Process Group 2

Process Group n

Multilevel Queue Scheduling

Intra-queue scheduling

Independent choice of scheduling algorithms.

Inter-queue scheduling

a. Fixed-priority preemptive scheduling

a. e.g., foreground queues always have absolute priority over background queues.

b. Time slice between queue

a. e.g., 80% CPU is given to foreground processes, and 20% CPU to background processes.

c. More??

(16)

Multilevel Feedback Queue Scheduling

Different from Multilevel Queue

Scheduling by Allowing Processes to Migrate Among Queues.

Configurable Parameters:

a. # of queues

b. The scheduling algorithm for each queue c. The method to determine when to upgrade a

process to higher priority queue.

d. The method to determine when to degrade a process to lower priority queue.

e. The method to determine which queue a newly ready process will enter.

*Inter-queue scheduling: Fixed-priority preemptive?!

Multilevel Feedback Queue Scheduling

Example

quantum = 8

quantum = 16

FCFS

*Idea: Separate processes with different CPU-burst characteristics!

(17)

Multiple-Processor Scheduling

CPU scheduling in a system with multiple CPUs

A Homogeneous System

Processes are identical in terms of their functionality.

ÎCan processes run on any processor?

A Heterogeneous System

Programs must be compiled for instructions on proper processors.

Multiple-Processor Scheduling

Load Sharing – Load Balancing!!

A queue for each processor

Self-Scheduling – Symmetric Multiprocessing

A common ready queue for all processors.

Master-Slave – Asymmetric Multiprocessing

Need synchronization to access common data structure, e.g., queues.

One processor accesses the system structures Æ no need for data sharing

(18)

Real-Time Scheduling

Definition

Real-time means on-time, instead of fast!

Hard real-time systems:

Failure to meet the timing constraints (such as deadline) of processes may result in a catastrophe!

Soft real-time systems:

Failure to meet the timing constraints may still contribute value to the system.

Real-Time Scheduling

Dispatch Latency

1. Preemption of the running process

2. Releasing resources needed by the higher priority process

3. Context switching to the higher priority process

Dispatch latency

Conflicts Dispatch

(19)

Real-Time Scheduling

Minimization of Dispatch Latency?

Context switching in many OS, e.g., some UNIX versions, can only be done after a system call completes or an I/O blocking occurs

Solutions:

1. Insert safe preemption points in long- duration system calls.

2. Protect kernel data by some

synchronization mechanisms to make the entire kernel perceptible.

Real-Time Scheduling

Priority Inversion:

A higher-priority processes must wait for the execution of a lower-priority

processes.

P1 P2 P3

D

Time

P3 also waits for P2 to complete?

D D D V

P1 P2

P3 D

Time

Request for D

(20)

Real-Time Scheduling

Priority Inheritance

The blocked process inherits the priority of the process that causes the blocking.

P1 P2 P3

D Time

D D D V

P1 P2

P3 D

Time

Request for D

Real-Time Scheduling

Earliest Deadline First Scheduling (EDF)

Processes with closer deadline have higher priorities.

An optimal dynamic-priority-driven scheduling algorithm for periodic and aperiodic processes!

)) / 1 ( ) (

(priority τ_i ∝ d_i

Liu & Layland [JACM 73] showed that EDF is optimal in the sense that a process set is

∑^ ^

(21)

Real-Time Scheduling – EDF

process P1 P2 P3

CPU Burst time 4

5 6

Period 20 15 16

Initial Arrival Time 0

1 2

=(11+0+4)/3=5

0 2 6 18 20

15

0 1 6 12

P2 P3 P1

P1

15

0 1 12 20

0 1 6 16 20

P3

12

A General Architecture of RTOS’s

Objectives in the Design of Many RTOS’s

Efficient Scheduling Mechanisms

Good Resource Management Policies

Predictable Performance

Common Functionality of Many RTOS’s

Task Management

Memory Management

Resource Control, including devices

Process Synchronization

(22)

A General Architecture

Bottom Half Top Half processes User

Space OS

hardware

Timer expires to

• Expire the running process’s time quota

• Keep the accounting info for each process

System calls such as I/O requests which may cause the releasing CPU of a process!

Interrupts for Services

A General Architecture

2-Step Interrupt Services

Immediate Interrupt Service

Interrupt priorities > process priorities

Time: Completion of higher priority ISR, context switch, disabling of certain interrupts, starting of the right ISR (urgent/low-level work, set events)

Scheduled Interrupt Service

Usually done by preemptable threads

Remark: Reducing of non-preemptable code, Priority Tracking/Inheritance (LynxOS), etc.

ISR

I

Interrupt/ISR Latency

SecheduledService

IST Latency

(23)

A General Architecture

Scheduler

A central part in the kernel

The scheduler is usually driven by a clock interrupt periodically, except when voluntary context switches occur – thread quantum?

Timer Resolution

Tick size vs Interrupt Frequency

10ms? 1ms? 1us? 1ns?

Fine-Grained hardware clock

A General Architecture

Memory Management

No protection for many embedded systems

Memory-locking to avoid paging

Process Synchronization

Sources of Priority Inversion

Nonpreemptible code

Critical sections

A limited number of priority levels, etc.

(24)

Algorithm Evaluation

A General Procedure

Select criteria that may include several measures, e.g., maximize CPU

utilization while confining the maximum response time to 1 second

Evaluate various algorithms

Evaluation Methods:

Deterministic modeling

Queuing models

Simulation

Implementation

Deterministic Modeling

A Typical Type of Analytic Evaluation

Take a particular predetermined workload and defines the performance of each algorithm for that workload

Properties

Simple and fast

Through excessive executions of a number of examples, treads might be identified

But it needs exact numbers for inputs, and its answers only apply those cases

Being too specific and requires too exact knowledge to be useful!

(25)

Deterministic Modeling

process P1 P2 P3 P4 P5

CPU Burst time 10 29 3 7 12

P3 P5 P2

0 3 10 20 61

P4 P1

32

Nonpreemptive Shortest Job First

P1 P2

0 10 20 40 50 61

P2 23

P4 P5 30

P2 P5 52

Round Robin (quantum =10)

P1

0 10 39 42 49 61

FCFC

Average Waiting Time (AWT)=(0+10+39+42+49)/5=28

AWT=(10+32+0+3+20)/5=13

AWT=(0+(10+20+2)+20+23+(30+10))/5=13

Queueing Models

Motivation:

Workloads vary and there is no stati set of processes

Models (~queueing-network analysis)

Workload:

a. Arrival rate: the distribution of times when processes arrive

b. The distributions of CPU & I/O bursts

Service rate

(26)

Queueing Models

Model a computer system as a network of servers. Each server has a queue of waiting processes

Compute average queue length, waiting time.., and so on.

Properties:

Generally useful but with limited

application to the classes of algorithms &

distributions

Assumptions are made to make

problems solvable => inaccurate results

Queueing Models

Example: Little’s formula

n = # of processes in queue λ = arrival rate

ω = average waiting time in queue

If n =14 & λ =7 processes/sec, then w

= 2 seconds.

w n = λ ∗

λ w steady state!

λ

(27)

Simulation

Motivation:

Get a more accurate evaluation.

Procedures:

Program a model of the computer system

Drive the simulation with various data sets

Randomly generated according to some probability distributions

=> inaccurate indicate only the occurrence frequency of events. Miss the order & the relationships of events.

Trace tapes: monitor the real system &

record the sequence of actual events.

Simulation

Properties:

Accurate results can be gotten but it could be expensive in terms of

computation time and storage space.

The coding, design, and debugging of a simulation can be a big job.

(28)

Implementation

Motivation:

Get more accurate results than a simulation!

Procedure:

Code scheduling algorithms

Put them in the OS

Evaluate the real behavior

Implementation

Difficulties:

Cost in coding algorithm and modifying OS

Reaction of users to a constantly changing OS

The environment in which algorithms are used will change

e.g., users may adjust their behaviors according to the selected algorithms

=> Separation of the policy and mechanism!

(29)

Process Scheduling Model

Process Local Scheduling

User-level threads

System Global Scheduling

Kernel-level threads

Process Scheduling Model – Solaris 2

Priority-Based Process Scheduling

Real-Time

System

Kernel processes

Time-Sharing

A default class

Interactive

Each LWP inherits its class from its parent process

low

(30)

Process Scheduling Model – Solaris 2

Real-Time

A guaranteed response

System

The priorities of system processes are fixed.

Time-Sharing

Multilevel feedback queue scheduling – priorities inversely proportional to time slices

Interactive

Prefer windowing process

Process Scheduling Model – Solaris 2

The selected thread runs until one of the following occurs:

It blocks.

It uses its time slice (if it is not a system thread).

It is preempted by a higher-priority thread.

(31)

Process Scheduling Model – Windows 2000

Priority-Based Preemptive Scheduling

Priority Class/Relationship: 0..31

Dispatcher: A process runs until

It is preempted by a higher-priority process.

It terminates

Its time quantum ends

It calls a blocking system call

Idle thread

Time quantum – thread

Increased after some waiting

Decreased after some computation

Favor foreground processes

Process Scheduling Model – Windows 2000

1 1

1 16

Idle

2 4

6 8

11 22

Lowest

3 5

7 9

12 23

Below normal

4 6

8 10 13

24

Normal

5 7

9 11 14

Above 25

normal

6 8

10 12

15 26

Highest

15 15

15 31

Time- critical

Idle priority Below

normal Normal

Above normal High

Real- time

Variable Class Real-Time Class

Base Priority

A Typical Class

(32)

Process Scheduling Model – Linux

A Time-Sharing Algorithm for Fairness

Credits = (credits / 2) + priority

Recrediting when no runnable process has any credits.

Favor interactive or I/O-bound processes

Real-Time Scheduling Algorithms

FCFS & RR as required by POSIX.1b

No scheduling in kernel space for conventional Linux

Chapter 6 CPU Scheduling

Contents