1. Operating Systems 1 K. Salah Module 2.2: CPU Scheduling Scheduling Types Scheduling Criteria Scheduling Algorithms Performance Evaluation

2. Operating Systems 2 K. Salah CPU SCHEDULING –The basic problem is as follows: How can OS schedule the allocation of CPU cycles to processes in system, to achieve “good performance”? –Components of CPU scheduling subsystem of OS:  Dispatcher – gives control of the CPU to the new process  Scheduler - selects next process from those in main memory (short-term scheduler)  Swapper - manages transfer of processes between main memory and secondary storage (medium-term scheduler)  Long-Term Scheduler - in a batch system, determines which and how many jobs to admit into system.

3. Operating Systems 3 K. Salah Types of Scheduling Algorithms –Preemptive: process may have CPU taken away before completion of current CPU burst (e.g. end of CPU quantum.) –Non-preemptive: processes always run until CPU burst completes –Static Priority –Dynamic Priority

4. Operating Systems 4 K. Salah Performance Criteria for Scheduling Scheduling (as an Optimization task): How to best order the ready queue for efficiency purposes. CPU utilization: % of time CPU in use Throughput: # of jobs completed per time unit Turnaround Time: wall clock time required to complete a job Waiting Time: amount of time process is ready but waiting to run Response Time: in interactive systems, time until system responds to a command Response Ratio: (Turnaround Time)/(Execution Time) -- long jobs should wait longer The overhead of a scheduling algorithm (e.g., data kept about execution activity, queue management, context switches) should also be taken into account. Kleinrock's Conservation Law: No matter what scheduling algorithm is used, you cannot help one class of jobs without hurting the other ones. Example: A minor improvement for short jobs (say, on waiting time) causes a disproportionate degradation for long jobs.

5. Operating Systems 5 K. Salah Basic Scheduling Algorithm FCFS - First-Come, First-Served –Non-preemptive –Ready queue is a FIFO queue –Jobs arriving are placed at the end of queue –first job in queue runs to completion of CPU burst Advantages: simple, low overhead Disadvantages: long waiting time, inappropriate for interactive systems, large fluctuations in average turnaround time are possible.

6. Operating Systems 6 K. Salah FCFS Example Pid Arr CPU Start Finish Turna Wait Ratio ---+---+---+-----+------+-----+----+----- A 0 3 0 3 3 0 1.0 B 1 5 3 8 7 2 1.4 C 3 2 8 10 7 5 3.5 D 9 5 10 15 6 1 1.2 E 12 5 15 20 8 3 1.6 ---+---+---+-----+------+-----+----+----- A 0 1 0 1 1 0 1.00 B 0 100 1 101 101 1 1.01 C 0 1 101 102 102 101 102.00 D 0 100 102 202 202 102 2.02

7. Operating Systems 7 K. Salah RR - Round Robin Preemptive version FCFS Treat ready queue as circular –arriving jobs placed at end –first job in queue runs until completion of CPU burst, or until time quantum expires –if quantum expires, job again placed at end

8. Operating Systems 8 K. Salah Properties of RR Advantages: simple, low overhead, works for interactive systems Disadvantages: if quantum too small, too much time wasted in context switching; if too large, approaches FCFS. Typical value: 10 - 100 msec Rule of thumb: choose quantum so that large majority (80- 90%) of jobs finish CPU burst in one quantum

9. Operating Systems 9 K. Salah SJF - Shortest Job First –non-preemptive –ready queue treated as a priority queue based on smallest CPU-time requirement  arriving jobs inserted at proper position in queue  shortest job (1st in queue) runs to completion Advantages: provably optimal w.r.t. average turnaround time Disadvantages: in general, unimplementable. Also, starvation possible! Can do it approximately: use exponential averaging to predict length of next CPU burst ==> pick shortest predicted burst next!

10. Operating Systems 10 K. Salah SJF - Shortest Job First SJF is Optimal: Let t 1, t 2, t 3,…, t n be the time taken for p 1, p 2, p 3, …,p n Also t 1 < t 2 <… < t n-1 < t n then the average turn around times for p i are: Tp 1 = t 1 ; Tp 2 = t 1 + t 2 ; Tp 3 = t 1 + t 2 + t 1 ; … Tp n = t 1 + t 2 + …+ t n-1 +t n ; average turnaround time = T A = (Tp 1 + Tp 2 +…+ Tp n ) / n = t 1 +(t 1 + t 2 )+(t 1 + t 2 + t 3 )+…+t n = nt 1 + (n-1) t 2 + (n-2) t 3 + …+ t n ) / n Now, if any of the t n is/are interchanged with t n-1 in the above equation T A ’ > T A, because (n-k) t j > (n-k) t k, where t j > t k Assumptions ? – Can p i (s) arrival times be different ?

11. Operating Systems 11 K. Salah Exponential Averaging  n+1  t n  n  n+1 : predicted length of next CPU burst t n : actual length of last CPU burst  n : previous prediction  : [0…1]  = 0 implies make no use of recent history  n+1  n   = 1 implies  n+1 = t n (past prediction not used).  = small value favor past history, larger value favors recent Why is keeping the history small good enough ? – Do the weight of the successive terms in the equation get smaller (why?)  n+1  t n  t n-1    t n-2  j  t n-j  j  0

12. Operating Systems 12 K. Salah SRTF - Shortest Remaining Time First –Preemptive version of SJF –Ready queue ordered on length of time till completion (shortest first) –Arriving jobs inserted at proper position –shortest job runs to completion (i.e. CPU burst finishes) or until a job with a shorter remaining time arrives (i.e. placed in the ready queue.)

13. Operating Systems 13 K. Salah Performance Evaluation Deterministic Modeling (vs. Probabilistic) Look at behavior of algorithm on a particular workload, and compute various performance criteria Example: workload - Job 1: 24 units Job 2: 3 units Job 3: 3 units Gantt chart for FCFS: | Job 1 | Job 2 | Job 3 | 0 24 27 30 Total waiting time: 0 + 24 + 27 = 51 Average waiting time: 51/3 = 17 Total turnaround time: 24 + 27 + 30 = 81 Average turnaround time: 81/3 = 27

14. Operating Systems 14 K. Salah RR and SJF Chart for RR with quantum of 3: | Job 1 | Job 2 | Job 3 | Job 1 | 0 3 6 9 30 Total waiting time: 6 + 6 + 3 = 15 Avg. waiting time: 15 / 3 = 5 Chart for SJF: | Job 2 | Job 3 | Job 1 | 0 3 6 30 Total waiting time: 6 + 0 + 3 = 9 Avg. waiting time: 9 / 3 = 3 Can see that SJF gives minimum waiting time. RR is intermediate. (This can be proved in general.)

15. Operating Systems 15 K. Salah HPF - Highest Priority First –general class of algorithms –each job assigned a priority which may change dynamically –may be preemptive or non-preemptive Problem: how to compute priorities? –SJF is a special case of priority; the longer the CPU burst, the lower the priority. –Priority can be internally computed, e.g., CPU burst vs. I/O burst. Or it can be externally defined depending on the importance of the process, (e.g. using nice command in Unix).