cpu scheduling - nmt computer science and engineeringcs325/spring2013/lec09-cpuscheduling.pdf2/12/13...

2/12/13 CSE325 - CPU Scheduling 1

CPU Scheduling

n  Process/thread schedulers

n  Scheduling Policies

n  Scheduling Algorithms n  First Come First Served

n  Shortest Job Next

n  Round Robin


CPU Scheduling

n  The problem: scheduling the usage of a processor among all the existing processes/threads in the system

n  The goal is to achieve n  High processor utilization

n  High throughput n  number of processes completed per unit time

n  Low response time n  time elapse from the submission of a request to the

beginning of the response


Model of Process Execution

Ready Queue

Scheduler CPU

Resource Manager

Resources

Preemption or voluntary yield

Allocate Request

Done New Process job

job job

job job

“Ready” “Running”

“Blocked”

CPU scheduling may occur for which four reasons?

CSE325 - CPU Scheduling 4

Queuing Diagram for Scheduling

n  Long-term: which process to admit

n  Medium-term: which process to swap in or out

n  Short-term: which ready process to execute next

2/12/13

5

Scheduling Policies

n  The selection function: determines which process in the ready queue is selected next for execution

n  The decision mode: specifies the instants in time at which the selection function is exercised n  Nonpreemptive or Cooperative

n  Once a process is in the running state, it will continue until it terminates or blocks itself for I/O

n  Preemptive n  Currently running process may be interrupted and moved to the

Ready state by the OS

n  Allows for better service since any one process cannot monopolize the processor for very long

2/12/13 CSE325 - CPU Scheduling


Policy Considerations

n  Policy can control/influence: n  CPU utilization

n  Average time a process waits for service

n  Average amount of time to complete a job

n  Could strive for any of: n  Equitability

n  Favor very short or long jobs

n  Meet priority requirements

n  Meet deadlines


Optimal Scheduling

n  Suppose the scheduler knows each process pi’s service time, τ(pi) -- or it can estimate each τ(pi)

n  Policy can optimize on any criteria, e.g., n  CPU utilization n  Waiting time n  Deadline

n  To find an optimal schedule: n  Have a finite, fixed # of pi n  Know τ(pi) for each pi n  Enumerate all schedules, then choose the best

Problems?


Problems ...

n  The τ(pi) are almost certainly just estimates

n  Time complexity for choosing optimal schedule is ?

n  Other processes may arrive while these processes are being serviced

n  Usually, optimal schedule is only a theoretical benchmark – scheduling policies try to approximate an optimal schedule

O(2n)

9

Talking About Scheduling ...

n  Let P = {pi | 0 ≤ i < n} = set of processes

n  Let S(pi) ∈ {running, ready, blocked}

n  Let τ(pi) = Time a process needs to be in running state (the service time)

n  Let W(pi) = Time pi is in ready state before its first transition to running (wait time)

n  Let TTRnd(pi) = Time from pi first enter into ready to last exit from ready (turnaround time)

n  Timesharing response time = W(pi)

CSE325 - CPU Scheduling 2/12/13


First-Come-First-Served (FCFS)

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0 TTRnd(p0) = τ(p0) = 350 W(p0) = 0

0 350


First-Come-First-Served

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0 p1

TTRnd(p0) = τ(p0) = 350 TTRnd(p1) = (τ(p1) +TTRnd(p0)) = 125+350 = 475

W(p0) = 0 W(p1) = TTRnd(p0) = 350

475 350



i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0 p1 p2 TTRnd(p0) = τ(p0) = 350 TTRnd(p1) = (τ(p1) +TTRnd(p0)) = 125+350 = 475 TTRnd(p2) = (τ(p2) +TTRnd(p1)) = 475+475 = 950

W(p0) = 0 W(p1) = TTRnd(p0) = 350 W(p2) = TTRnd(p1) = 475

475 950



i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0 p1 p2 p3

TTRnd(p0) = τ(p0) = 350 TTRnd(p1) = (τ(p1) +TTRnd(p0)) = 125+350 = 475 TTRnd(p2) = (τ(p2) +TTRnd(p1)) = 475+475 = 950 TTRnd(p3) = (τ(p3) +TTRnd(p2)) = 250+950 = 1200

W(p0) = 0 W(p1) = TTRnd(p0) = 350 W(p2) = TTRnd(p1) = 475 W(p3) = TTRnd(p2) = 950

1200 950



i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0 p1 p2 p3 p4

TTRnd(p0) = τ(p0) = 350 TTRnd(p1) = (τ(p1) +TTRnd(p0)) = 125+350 = 475 TTRnd(p2) = (τ(p2) +TTRnd(p1)) = 475+475 = 950 TTRnd(p3) = (τ(p3) +TTRnd(p2)) = 250+950 = 1200 TTRnd(p4) = (τ(p4) +TTRnd(p3)) = 75+1200 = 1275

W(p0) = 0 W(p1) = TTRnd(p0) = 350 W(p2) = TTRnd(p1) = 475 W(p3) = TTRnd(p2) = 950 W(p4) = TTRnd(p3) = 1200

1200 1275

15

FCFS Average Wait Time

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0 p1 p2 p3 p4

TTRnd(p0) = τ(p0) = 350 TTRnd(p1) = (τ(p1) +TTRnd(p0)) = 125+350 = 475 TTRnd(p2) = (τ(p2) +TTRnd(p1)) = 475+475 = 950 TTRnd(p3) = (τ(p3) +TTRnd(p2)) = 250+950 = 1200 TTRnd(p4) = (τ(p4) +TTRnd(p3)) = 75+1200 = 1275

W(p0) = 0 W(p1) = TTRnd(p0) = 350 W(p2) = TTRnd(p1) = 475 W(p3) = TTRnd(p2) = 950 W(p4) = TTRnd(p3) = 1200

Wavg = (0+350+475+950+1200)/5 = 2974/5 = 595

1275 1200 900 475 350 0

• Easy to implement • Ignores service time, etc • Not a great performer

Pros and Cons

TTRand_avg = 850 2/12/13 CSE325 - CPU Scheduling


Shortest-Job-First (SJF)

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p4 TTRnd(p4) = τ(p4) = 75

W(p4) = 0

75 0


Shortest-Job-First

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p1 p4 TTRnd(p1) = τ(p1)+τ(p4) = 125+75 = 200 TTRnd(p4) = τ(p4) = 75

W(p1) = 75 W(p4) = 0

200 75 0


Shortest-Job-First

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p1 p3 p4 TTRnd(p1) = τ(p1)+τ(p4) = 125+75 = 200 TTRnd(p3) = τ(p3)+τ(p1)+τ(p4) = 250+125+75 = 450 TTRnd(p4) = τ(p4) = 75

W(p1) = 75 W(p3) = 200 W(p4) = 0

450 200 75 0


Shortest-Job-First

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0 p1 p3 p4 TTRnd(p0) = τ(p0)+τ(p3)+τ(p1)+τ(p4) = 350+250+125+75 = 800 TTRnd(p1) = τ(p1)+τ(p4) = 125+75 = 200 TTRnd(p3) = τ(p3)+τ(p1)+τ(p4) = 250+125+75 = 450 TTRnd(p4) = τ(p4) = 75

W(p0) = 450 W(p1) = 75 W(p3) = 200 W(p4) = 0

800 450 200 75 0

Shortest-Job-First


i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0 p1 p2 p3 p4 TTRnd(p0) = τ(p0)+τ(p3)+τ(p1)+τ(p4) = 350+250+125+75 = 800 TTRnd(p1) = τ(p1)+τ(p4) = 125+75 = 200 TTRnd(p2) = τ(p2)+τ(p0)+τ(p3)+τ(p1)+τ(p4) = 475+350+250+125+75 = 1275 TTRnd(p3) = τ(p3)+τ(p1)+τ(p4) = 250+125+75 = 450 TTRnd(p4) = τ(p4) = 75

W(p0) = 450 W(p1) = 75 W(p2) = 800 W(p3) = 200 W(p4) = 0

1275 800 450 200 75 0

21

Shortest-Job-First

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0 p1 p2 p3 p4 TTRnd(p0) = τ(p0)+τ(p3)+τ(p1)+τ(p4) = 350+250+125+75 = 800 TTRnd(p1) = τ(p1)+τ(p4) = 125+75 = 200 TTRnd(p2) = τ(p2)+τ(p0)+τ(p3)+τ(p1)+τ(p4) = 475+350+250+125+75 = 1275 TTRnd(p3) = τ(p3)+τ(p1)+τ(p4) = 250+125+75 = 450 TTRnd(p4) = τ(p4) = 75

W(p0) = 450 W(p1) = 75 W(p2) = 800 W(p3) = 200 W(p4) = 0

Wavg = (450+75+800+200+0)/5 = 1525/5 = 305

1275 800 450 200 75 0

• Minimizes wait time • May starve large jobs • Must know service times

Pros and Cons

TTRand_avg = 560 CSE325 - CPU Scheduling 2/12/13


Preemptive Schedulers

Ready List

Scheduler CPU

Preemption or voluntary yield

Done New Process

n  Highest priority process is guaranteed to be running at all times n  Or at least at the beginning of a time slice

n  Dominant form of contemporary scheduling

n  But complex to build & analyze


Round Robin (RR) [TQ=50]

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0

W(p0) = 0

0 50


Round Robin (TQ=50)

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0

W(p0) = 0 W(p1) = 50

100 0 p1


Round Robin (TQ=50)

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0

W(p0) = 0 W(p1) = 50 W(p2) = 100

100 0 p2 p1


Round Robin (TQ=50)

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0

W(p0) = 0 W(p1) = 50 W(p2) = 100 W(p3) = 150

200 100 0 p3 p2 p1


Round Robin (TQ=50)

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0

W(p0) = 0 W(p1) = 50 W(p2) = 100 W(p3) = 150 W(p4) = 200

200 100 0 p4 p3 p2 p1


Round Robin (TQ=50)

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0

W(p0) = 0 W(p1) = 50 W(p2) = 100 W(p3) = 150 W(p4) = 200

300 200 100 0 p0 p4 p3 p2 p1


Round Robin (TQ=50)

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0

TTRnd(p4) = 475

W(p0) = 0 W(p1) = 50 W(p2) = 100 W(p3) = 150 W(p4) = 200

475 400 300 200 100 0 p4 p0 p4 p3 p2 p1 p1 p2 p3


Round Robin (TQ=50)

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0

TTRnd(p1) = 550 TTRnd(p4) = 475

W(p0) = 0 W(p1) = 50 W(p2) = 100 W(p3) = 150 W(p4) = 200

475 400 300 200 100 0 p4 p1 p0 p4 p3 p2 p1 p1 p2 p3 p0

550


Round Robin (TQ=50)

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0

TTRnd(p1) = 550 TTRnd(p3) = 950 TTRnd(p4) = 475

W(p0) = 0 W(p1) = 50 W(p2) = 100 W(p3) = 150 W(p4) = 200

475 400 300 200 100 0 p4 p1 p0 p4 p3 p2 p1 p1 p2 p3 p0 p3 p2

p0 p3 p2 p0 p3 p2

550 650

650 750 850 950


Round Robin (TQ=50)

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0

TTRnd(p0) = 1100 TTRnd(p1) = 550 TTRnd(p3) = 950 TTRnd(p4) = 475

W(p0) = 0 W(p1) = 50 W(p2) = 100 W(p3) = 150 W(p4) = 200

475 400 300 200 100 0 p4 p1 p0 p4 p3 p2 p1 p1 p2 p3 p0 p3 p2

p0 p3 p2 p0 p3 p2 p0 p2 p0

550 650

650 750 850 950 1050


Round Robin (TQ=50)

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0

TTRnd(p0) = 1100 TTRnd(p1) = 550 TTRnd(p2) = 1275 TTRnd(p3) = 950 TTRnd(p4) = 475

W(p0) = 0 W(p1) = 50 W(p2) = 100 W(p3) = 150 W(p4) = 200

475 400 300 200 100 0 p4 p1 p0 p4 p3 p2 p1 p1 p2 p3 p0 p3 p2

p0 p3 p2 p0 p3 p2 p0 p2 p0 p2 p2 p2 p2

550 650

650 750 850 950 1050 1150 1250 1275

Round Robin (TQ=50)

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0


W(p0) = 0 W(p1) = 50 W(p2) = 100 W(p3) = 150 W(p4) = 200

Wavg = (0+50+100+150+200)/5 = 500/5 = 100

475 400 300 200 100 0

•  Equitable •  Most widely-used •  Fits naturally with interval timer

p4 p1 p0 p4 p3 p2 p1 p1 p2 p3 p0 p3 p2

p0 p3 p2 p0 p3 p2 p0 p2 p0 p2 p2 p2 p2

550 650

650 750 850 950 1050 1150 1250 1275

TTRnd_avg = (1100+550+1275+950+475)/5 = 4350/5 = 870

34 2/12/13 CSE325 - CPU Scheduling

RR with Overhead=10 (TQ=50)

i τ(pi) 0 350 1 125 2 475 3 250 4 75

p0


W(p0) = 0 W(p1) = 60 W(p2) = 120 W(p3) = 180 W(p4) = 240

Wavg = (0+60+120+180+240)/5 = 600/5 = 120

540 480 360 240 120 0

•  Overhead must be considered

p4 p1 p0 p4 p3 p2 p1 p1 p2 p3 p0 p3 p2

p0 p3 p2 p0 p3 p2 p0 p2 p0 p2 p2 p2 p2

575 790

910 1030 1150 1270 1390 1510 1535

TTRnd_avg = (1320+660+1535+1140+565)/5 = 5220/5 = 1044

635 670

790

2/12/13 35 CSE325 - CPU Scheduling

Priority Scheduling

i τ(pi) Pri 0 350 5 1 125 2 2 475 3 3 250 1 4 75 4 p0 p1 p2 p3 p4

TTRnd(p0) = τ(p0)+τ(p4)+τ(p2)+τ(p1) )+τ(p3) = 350+75+475+125+250 = 1275 TTRnd(p1) = τ(p1)+τ(p3) = 125+250 = 375 TTRnd(p2) = τ(p2)+τ(p1)+τ(p3) = 475+125+250 = 850 TTRnd(p3) = τ(p3) = 250 TTRnd(p4) = τ(p4)+ τ(p2)+ τ(p1)+τ(p3) = 75+475+125+250 = 925

W(p0) = 925 W(p1) = 250 W(p2) = 375 W(p3) = 0 W(p4) = 850

Wavg = (925+250+375+0+850)/5 = 2400/5 = 480

1275 925 850 375 250 0

• Reflects importance of external use • May cause starvation • Can address starvation with aging

Pros and Cons

WTRand_avg = 735 CSE325 - CPU Scheduling 2/12/13 36


Deadline Scheduling

i τ(pi) Deadline 0 350 575 1 125 550 2 475 1050 3 250 (none) 4 75 200

p0 p1 p2 p3 p4 1275

1050 550 200 0

• Allocates service by deadline • May not be feasible

p0 p1 p2 p3 p4

p0 p1 p2 p3 p4

575 d4 d1 d0 d2

38

Multiple Feedback Queues

n  FCFS is used in each queue except for lowest priority queue where Round Robin is used


39

Multilevel Feedback Scheduling

n  Preemptive scheduling with dynamic priorities n  Several ready to execute queues with decreasing priorities:

n  P(RQ0) > P(RQ1) > ... > P(RQn)

n  New processes are placed in RQ0

n  When they reach the time quantum, they are placed in RQ1. If they reach it again, they are place in RQ2... until they reach RQn

n  I/O-bound processes will stay in higher priority queues. CPU-bound jobs will drift downward.

n  Dispatcher chooses a process for execution in RQi only if RQi-1 to RQ0 are empty

n  Hence long jobs may starve


40

Time Quantum for feedback Scheduling

n  With a fixed quantum time, the turnaround time of longer processes can stretch out alarmingly

n  To compensate, we can increase the time quantum according to the depth of the queue

n  Ex: time quantum of RQi = 2^{i-1}

n  Longer processes may still suffer starvation. n  Possible fix: promote a process to higher priority after some time

CSE325 - CPU Scheduling 2/12/13

41

Algorithm Comparison

n  Which one is the best?

n  The answer depends on: n  the system workload (extremely variable)

n  hardware support for the dispatcher

n  relative weighting of performance criteria (response time, CPU utilization, throughput...)

n  The evaluation method used (each has its limitations...)

n  Hence the answer depends on too many factors to give any...


cpu scheduling - nmt computer science and engineeringcs325/spring2013/lec09-cpuscheduling.pdf2/12/13...

Documents