© DEEDS – OS 1

Overview

Resource Sharing & Inter-Process Interactions Issues and Problems (Deadlocks, CS, ME…) Task Orderings (Scheduling …) Algorithmic Solutions (Races, ME…) Program Level Solutions (Semaphores, Monitors)

© DEEDS – OS 2

Deadlocks Starvation

How to allocate a resource to have progress… – Let’s get a task running!!! E.g. shortest job first

Works great for multiple short jobs in a system May cause a long job to be postponed indefinitely with shorter ones jumping ahead

… even though this is “waiting” and not blocked

Alternates?– First-come, first-serve (FIFO) policy, Round Robin Slotting– Shortest job first, highest priority first, earliest deadline first, random …

Resource Allocation: Efficient? Fair? Optimal?

© DEEDS – OS 3

OS Scheduling Criteria (Optimizations)

• CPU utilization: keep CPU as busy as possible (maximize)– Nice but the CPU better be doing something useful! Remember livelock?

• Throughput: # of processes completed/time unit (maximize)

• Turnaround time: average amount of time to execute a particular process (minimize)

• Waiting time: process wait time in ready queue (minimize)• Response time (minimize): amount of time it takes from when

a request was submitted until the first response (not output) is produced. [result output time = RT deadline]

Optimize all plus want “Fair & Efficient” solutions!

© DEEDS – OS 4

1. Task/Process/Thread Types

• Non pre-emptive (NP): An ongoing task cannot be displaced

• Pre-emptive: Ongoing tasks can be switched in/out as needed

© DEEDS – OS 5

2. Sequences of CPU And I/O Bursts

Apps typically stay CPU or I/O-bound – Hybrids generally for interactive apps

© DEEDS – OS 6

Scheduling Variants (Processes/Threads)

• First Come, First Served (FCFS)• Shortest Job First (SJF)• Round Robin (RR)• Priority Based (PB)

© DEEDS – OS 7

A: First-Come, First-Served (FCFS) Scheduling

(Non-Preemptive)Process Length (CPU Burst Time)

P1 24

P2 3

P3 3

• Processes arrive (& get executed) in their arrival order: P1 , P2 , P3

Gantt Chart for the schedule (single queue of ready processes: NP):

• Waiting time for P1 = 0; P2 = 24; P3 = 27• Average waiting time: (0 + 24 + 27)/3 = 17

P1 P2 P3

24 27 300

© DEEDS – OS 8

FCFS Scheduling (NP: Non-Preemptive)

Suppose that the processes arrive in a different order as:

P2 , P3 , P1 [3,3,24]

• Gantt chart for the schedule:

• Waiting time for P1 = 6; P2 = 0; P3 = 3

• Average waiting time: (6 + 0 + 3)/3 = 3

Variability of wait time (from 17 to 3!) – control? response prediction? Convoy effect: cluster short processes behind long process (starvation

possible!)

P1P3P2

63 300

© DEEDS – OS 9

Scheduling in Batch Systems where we can actually see and re-order FCFS?

Shortest job first (SJF) scheduling?

© DEEDS – OS 10

B: Shortest-Job-First (SJF) Scheduling

• Associate with each process the length of its next CPU burst

• Use these lengths to schedule the process with the shortest time

Options: non-preemptive – once CPU given to the process it cannot be preempted

until it completes its CPU burst

– preemptive – if a new process arrives with CPU burst length less than remaining time of current executing process, preempt.

Variation: Shortest-Remaining-Time-First (SRTF)

© DEEDS – OS 11

Process Arrival Time Burst Time

P1 0.00 7

P2 0.0+ 4

P3 0.0+ 1

P4 0.0+ 4

• SJF (non-preemptive) P1, then P3 then P2, P4 (FCFS across equals)

• Average waiting time = (0 + 8 + 7 + 12)/4 = 6.75 (fixed arrival)

• Av. waiting = (0 + [8-2] + [7-4] + [12-5])/4 = 4.00 (staggered arrival)

Example of Non-Preemptive SJF

P1 P3 P2

73 160

P4

8 12

0.0

2.0

4.0

5.0

© DEEDS – OS 12

Shortest-Job-First (SJF) Scheduling

• Associate with each process the length of its next CPU burst

• Use these lengths to schedule the process with the shortest time

Options: – non-preemptive – once CPU given to the process it cannot be preempted

until it completes its CPU burst preemptive – if a new process arrives with CPU burst length less than

remaining time of current executing process, preempt. Variation: Shortest-Remaining-Time-First (SRTF)

© DEEDS – OS 13

Preemptive SJF(Shortest Remaining Time First: Reassess SRT on Arrivals)

Process Arrival Time Burst Time

P1 0.0 7

P2 2.0 4

P3 4.0 1

P4 5.0 4

• SJF (preemptive)

• Average waiting time = P1:[0, (11-2)]; P2:[0, (5-4)]; P3: 0; P4: (7-5)

• Average waiting time = (9 + 1 + 0 +2)/4 = 3 …[6.75;4.00]

• Dynamic scheduling (SRT) calculations + context switches cost factor!

P1 P3P2

42 110

P4

5 7

P2 P1

16

P1: 5 left P2: 2 left P2:2, P4:4, P1:5

© DEEDS – OS 14

Determining Length of Next CPU Burst

• Can only estimate the task length (simple for batch jobs)

• Use the length of previous CPU bursts (history logs & ageing)

nn 1:Define 4.

1;0 , 3.

burst CPUnext for the valuepredicted 2.

burst CPU oflength actual 1.

1

n

thn nt

.1 1 nnn t

nn t1(0) direct fn. of history

(1) direct fn. of most recent run

τ1 = ½ to + ½ τ0 <add + simple left shift (divide by 2!)>

τ2 = ½ t1 + ½ τ1 = ½ t1 + ½ ( ½ t0 + ½ τ0) = ½ t1 + ¼ t0 + ¼ τ0

τ3 = ½ t2 + ½ τ2 = ½ t2 + ¼ t1 + 1/8 t0 + 1/8 τ0

© DEEDS – OS 15

Shortest-Job-First (SJF) Scheduling

• Associate with each process the length of its next CPU burst

• Use these lengths to schedule the process with the shortest time

Options: – non-preemptive – 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. Shortest-Remaining-Time-First (SRTF)

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

• SJF can still lead to starvation: if new short jobs keep coming in and getting considered in the “shortest” ranking, a “long” job can potentially starve!

© DEEDS – OS 16

Variations

• SJF EDF (Earliest Deadline First)

© DEEDS – OS 17

Onwards to Preemptive Scheduling

© DEEDS – OS 18

C: *Round Robin (RR/TDMA): Fixed Slots• Each process gets a fixed slice of CPU time (time quantum: q), 10-100ms

– After this time has elapsed, the process is “forcefully” 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 too large FIFO (poor response time & poor CPU utilization)

– q too small q must be large with respect to context switch ovhd., else context switching overhead reduces efficiency

ReadyQ

a a a bbb cc

© DEEDS – OS 19

Example of RR with Time Quantum = 20Rudimentary Static RR!

Process Burst TimeP1 53 P2 17 P3 68 P4 24

P1 P2 P3 P4 P1 P3 P4 P1

0 20 40 60 80 100 120 140 160 180 200

37 144 173

© DEEDS – OS 20

Better Dynamic RR with Quantum = 20Dynamic Q: if a process finishes in less than 20, then the next slot starts earlier!

Process Burst TimeP1 53 P2 17 P3 68 P4 24

• Typically, higher average turnaround than SJF, but better response– Turnaround time – amount of time to execute a particular process (minimize)– Response time (min) – amount of time it takes from request submission until first response

• Scheduling is static though calculating/estimation “right” length of quantum is crucial!!!

• Possible to have quanta of varying lengths!!! (dynamic scheduling costs ~ SJF)

P1 P2 P3 P4 P1 P3 P4 P1 P3 P3

0 20 37 57 77 97 117 121 134 154 162

© DEEDS – OS 21

D: *Priority Scheduling (RR All tasks have same priority)

• A priority number (integer) is associated with each process• The CPU is allocated to process with the highest priority

(For Unix BSD: smallest integer highest priority)

– Preemptive (priority and order changes possible at runtime)

– Non-preemptive (initial execution order chosen by static priorities)

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 priority of process

© DEEDS – OS 22

Ageing and Priority

• Priority can be static or dynamic (as a function of wait-time & usage-time for fairness etc: Unix BSD, Linux)

Note: In BSD Large # =‘s Low Priority!

P_user-pri = P_USER + P_cpu/4 + (2 * P_nice)

process using CPU: P_cpu increases with time P_user-pri goes up (ie lower priority)

process waiting: P_cpu keeps decreasing P_user-pri keeps going down (ie higher priority)

© DEEDS – OS 23

Priority Scheduling (Solaris, Windows, Linux)

• Kernel process: generally non-preemptive • User processes: mostly pre-emptable

(FCFS within a priority level)

Higher Priority: Small quantaLower Priority: Bigger quanta

© DEEDS – OS 24

Which Scheduling Policy to Use?

• OS schedulers implement *all* policies• The nature of specific applications (computing, I/O,

multimedia etc) and the mixture of applications (at kernel- level, at user-level) determines the specific scheduling policy or groups of policies to use!

• Kernel and user-level schedulers can be the same or more generally discrete at each level.

24

© DEEDS – OS 25

Thread Scheduling• Local Scheduling – How the threads library decides which thread to

put onto an available LWP

• Global Scheduling – How the kernel decides which kernel thread to run next

© DEEDS – OS 26

Thread Scheduling (User Scheduler)

Possible scheduling of user-level threads• 50-msec process quantum; threads run 5 msec/CPU burst• simple process level context switch; thread block process blocks• split level scheduling (kernel + dedicated application/thread type specific)

© DEEDS – OS 27

Thread Scheduling (Kernel Scheduler)

Possible scheduling of kernel-level threads• 50-msec process quantum; threads run 5 msec/CPU burst• flexible…costly full context switch for threads• monolithic kernel scheduler also avoids thread blocks (on I/O etc)

© DEEDS – OS 28

OS Examples

• Solaris scheduling

• Windows scheduling

• Linux scheduling

All work with dynamically altering priorities & time slicesAll have pre-emptive tasking

© DEEDS – OS 29

Solaris 2 (& Linux) Scheduling

Higher the priority,shorter the time slice

© DEEDS – OS 30

Solaris Dispatch Table

* Lowest priority 0 (diff. from BSD) is given largest quantum TQE: new (reduced) priority for tasks that have used quanta without blocking (CPU Intensive Tasks) ; Solaris 9+ : No TQE (fixed priority & CPU shares) RFS: (raised) priority of awakened tasks (responsiveness for I/O Tasks)

TQE RFS

(msec)

New dynamically altered priorities…and time slots

CPU-tasks mid-priority,Interactive: higher priority

© DEEDS – OS 31

Windows: Priority Based, Preemptive(Fixed & Variable Components)

priority classes

relative priority within a priority class (High # =‘s High Priority; diff. from BSD)

Fixed Priority Class (RT) will always run when invoked-Thread runs till quanta finished; priority lowered; task coming in from “wait” gets priority raised – only within its priority class!

© DEEDS – OS 32

Linux Scheduling (0=highest)

Two algorithms: time-sharing and real-time• Time-sharing

– Prioritized credit-based – process with most credits is scheduled next

– Credit subtracted when timer interrupt occurs– When credit = 0, another process chosen– When all processes have credit = 0, re-crediting occurs

• Based on factors including priority and history

• Real-time– Soft real-time– Two classes

• FCFS and RR• Highest priority process always runs first