1

Fair Resource Access & Allocation OS Scheduling

2

Scheduling Criteria (Optimization)

• CPU utilization: keep CPU as busy as possible (maximize)

• 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 (min): 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!

3

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

4

2. Sequences of CPU And I/O Bursts

Patterns can be CPU or I/O-bound

5

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

Process Length (CPU Burst Time)

P1 24

P2 3

P3 3

• Suppose the processes arrive in the 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

6

FCFS Scheduling (NP: Non-Preemptive)

Suppose that the processes arrive in the order

P2 , P3 , P1

• 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 – control? Convoy effect: cluster short processes behind long process (starvation

possible!)

P1P3P2

63 300

7

Scheduling in Batch Systems

Shortest job first (SJF) scheduling

8

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.

… Shortest-Remaining-Time-First (SRTF)

9

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

• 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

10

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. … Shortest-Remaining-Time-First (SRTF)

11

Preemptive SJF(Shortest Remaining Time First)

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: cost factor!

P1 P3P2

42 110

P4

5 7

P2 P1

16

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

12

Determining Length of Next CPU Burst

• Can only estimate the length (easy for batch jobs)

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

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

13

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!

14

Variations

• SJF EDF (Earliest Deadline First)

15

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

16

Example of RR with Time Quantum = 20(Dynamic 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

• Gantt chart:

• 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

17

D: Priority Scheduling

• 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

– Non-preemptive

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

• Problem Starvation: low priority processes may never execute– also…remember priority-inversion case? Interrupt Disabling for ME? Spinlock cases?

• Solution Aging: as time progresses increase priority of process

18

Priority Scheduling (Solaris, Windows, Linux)

* Kernel process: generally non-preemptive; User processes: pre-emptable• Priority can be static or dynamic (fn. time for fairness etc)

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

process using CPU: P_cpu increases with time P_user-pri goes up (BSD: large # =‘s low priority )

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

(FCFS within a priority level)

Higher Priority: Small quantaLower Priority: Bigger quanta

19

Scheduling in Real-Time Systems Hard/Firm/Soft Real-time: Missing deadline catastrophic/acceptable

Issues: Priority, periodicity, compute time, deadlines

• Periodic Task Model: Process assigned static priority based on their run_length (or period): Shortest Period Highest Priority (RM)

Schedulable real-time system, given:• m periodic events• event i occurs within period Pi and requires Ci seconds

– Then the load can only be handled if

• Composite Periodic/A periodic Model: Dynamic priority with highest priority to task whose deadline is closest! EDF: Earliest Deadline First

1

1m

i

i i

C

P

20

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

21

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)

22

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)

23

OS Examples

• Solaris scheduling

• Windows XP scheduling

• Linux scheduling

24

Solaris 2 Scheduling

25

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* RFS: (raised) priority of awakened tasks

26

Windows XP: Priority Based, Preemptive

priority classes

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

27

Linux Scheduling

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