CS444/CS544Operating Systems

Scheduling

1/31/2007

Prof. Searleman

jets@clarkson.edu

CS444/CS544 Spring 2007

CPU Scheduling

Reading assignment: Chapter 5

HW#3: done in lab 2-2-2007HW#4 posted, due: 2-7-2007

Help for Lab1, 6-7 pm tonight in ITL/COSI

Benefits of Concurrency

Hide latency of blocking I/O without additional complexity Without concurrency

Block whole process Manage complexity of asynchronous I/O (periodically checking

to see if it is done so can finish processing) Ability to use multiple processors to accomplish the

task Servers often use concurrency to work on multiple

requests in parallel User Interfaces often designed to allow interface to be

responsive to user input while servicing long operations

Scheduling CPU or “short term” scheduler selects process

from ready queue (every 10 msec or so) “dispatcher” does the process switching “long-term” scheduler controls “degree of

multiprogramming” (number of processes in memory); selects a good “job mix”

“job mix” – I/O-bound, CPU-bound, interactive, batch, high priority, background vs. foreground, real-time

“non-preemptive” (cooperative) vs. “preemptive”

Performance Measures

Throughput: #processes/time unit Turnaround time: time completed – time submitted Waiting time: sum of times spent in ready queue Response time: time from submission of a request

until the first response is produced Variation of response time (predictability)

CPU utilization Disk (or other I/O device) utilization

I/O-bound & CPU-boundDevice1

P1

CPU

P2

CPU

Device2

time quantum

I/O-bound & CPU-bound

P1: CPU-bound

Device1 idle

CPU idle CPU idle

Device1 idle Device1 idle

Turnaround time for P1

I/O-bound & CPU-bound

P2: I/O-bound

Device2 idle

CPU idle CPU idle

Device2 idle

Turnaround time for P2

I/O-bound & CPU-bound

Schedule1: non-preemptive, P1 selected first

Turnaround time for P2

Turnaround time for P1

Without P1

I/O-bound & CPU-bound

Schedule2: non-preemptive, P2 selected first

Turnaround time for P2

Turnaround time for P1

I/O-bound & CPU-bound

How does the OS know whether a process is

I/O-bound or CPU-bound?

- can monitor the behavior of a process & save the info in the PCB

- example: how much CPU time did the process use in its recent time quanta? (a small fraction => I/O intensive; all of the quantum => CPU intensive)

The nature of a typical process changes from I/O-bound to CPU-bound and back as it works through its Input/Process/Output Cycle

Preemptive vs. Non-Preemptive

t0

ready: P1, P2

t1

ready: P2blocked: P1

t2

Preemptive vs. Non-Preemptive

t3

ready: P2running: P1

t2

ready: P1blocked: P2

Non-Preemptive: must continue to run P1 at t3

Preemptive: can choose between P1 & P2 at t3

New

Ready Running

Waiting

Terminatedadmit dispatch

(4)exit,abort

(2)interrupt

(1)block for I/Oor wait for event

(3)I/O completedor event occurs

• nonpreemptive (cooperative): (1) and (4) only

• preemptive: otherwise

First Come First Serve (FCFS)

Also called First In First Out (FIFO) Jobs scheduled in the order they arrive When used, tends to be non-preemptive

If you get there first, you get all the resource until you are done

“Done” can mean end of CPU burst or completion of job

Sounds fair All jobs treated equally No starvation (except for infinite loops that prevent

completion of a job)

FCFS

average waiting time = (0 + 18 + 20)/3 = 12.6

P1

18

P2

20

P3

24

Process CPU burst

P1 18

P2 2

P3 4Gantt chart

0

P1, P2, P3ready

Problems with FCFS/FIFO

Can lead to poor overlap of I/O and CPU If let first in line run till they are done or block for

I/O then can get convoy effect While job with long CPU burst executes, other

jobs complete their I/O and the I/O devices sit idle even though they are the “bottleneck” resource and should be kept as busy as possible

Also, small jobs wait behind long running jobs (even grocery stores know that) Results in high average turn-around time

Shortest Job First (SJF)

So if we don’t want short running jobs waiting behind long running jobs, why don’t we let the job with the shortest CPU burst go next Can prove that this results in the minimum

(optimal) average waiting time Can be preemptive or non-preemptive

Preemptive version called shortest-remaining-time first (SRTF)

SJF

average waiting time = (0 + 2 + 6)/3 = 2.6

P1

24

P2

2

P3

6

Process CPU burst

P1 18

P2 2

P3 4Gantt chart

0

P1, P2, P3ready

SJF

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

P1

7

P2

12

P3

80

P1

ready

Process Arrival time

CPU burst

P1 0 7

P2 2 4

P3 4 1

P4 5 4

P4

16

nonpreemptive

2

P1 running

P2 ready

4

P1 running

P2 , P3 ready

5

P1 running

P2 , P3 , P4 ready

SRTF

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

P1 P3

0

P1

ready

Process Arrival time

CPU burst

P1 0 7

P2 2 4

P3 4 1

P4 5 4

P4

11

preemptive

2

P1 running

P2 ready

4

P2 running

P1 , P3 ready

5

P3 completes

P1 , P2 , P4 ready

P2 P2

16

P1

7

P1 , P4 ready

P1 ready

SRTF

average waiting time = (9 + 1 + 0 + 2)/4 = 3 average turnaround time = (16 + 5 + 1 + 6)/4

P1 P3

0

Process turnaround

Time

waiting

Time

P1

P2

P3

P4

P4

112 4 5

P2 P2

16

P1

7

16 – 0 = 167 – 2 = 5 15 – 4 = 111 – 5 = 6

9

0

2

preemptive

Problems with SJF

First, how do you know which job will have the shortest CPU burst or shortest running time? Can guess based on history but not guaranteed

Bigger problem is that it can lead to starvation for long-running jobs If you never got to the head of the grocery queue

because someone with a few items was always cutting in front of you