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: ( )/3 = 17 P1 P2 P3 24 27 30

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: ( )/3 = 3
Variability of wait time – control?
Convoy effect: cluster short processes behind long process (starvation possible!) P1 P3 P2 6 3 30

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. Example of Non-Preemptive SJF
Process Arrival Time Burst Time P P P P
SJF (non-preemptive) P1, then P3 then P2, P4 (FCFS here)
Average waiting time = ( )/4 = 6.75 (fixed arrival)
Av. waiting = (0 + [8-2] + [7-4] + [12-5])/4 = 4.00 (staggered arrival)
0.0
2.0
4.0
5.0 P1 P3 P2 7 3 16 P4 8 12

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 P P P P
SJF (preemptive)
Average waiting time = P1:[0, (11-2)]; P2:[0, (5-4)]; P3: 0; P4: (7-5)
Average waiting time = ( )/4 = 3 …[6.75;4.00]
Dynamic scheduling (SRT) calculations: cost factor!
P1: 5 left
P2: 2 left
P2:2, P4:4, P1:5 P1 P3 P2 4 2 11 P4 5 7 16

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)
(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), ms
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 Time
P1 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 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)
(FCFS within a priority level)
Higher Priority: Small quanta
Lower Priority: Bigger quanta
* 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)

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

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