1. COT 4600 Operating Systems Spring 2011 Dan C. Marinescu Office: HEC 304 Office hours: Tu-Th 5:00-6:00 PM

2. Lecture 20 - Tuesday April 5, 2011 Last time:  Tread coordination with a bounded buffer Today:  Scheduling  Multi-level memories  Memory characterization  Multilevel memories management using virtual memory  Adding multi-level memory management to virtual memory Next Time:  Page replacement algorithms Lecture 202

3. Scheduling Basic concepts; scheduling objectives. Scheduling policies  First-Come First-Serve (FCFS)  Shortest Job First (SJF)  Round Robin (RR)  Preemptive/non-preemptive scheduling  Priority scheduling Priority inversion Schedulers  CPU burst. Estimation of the CPU burst  Multi-level queues  Multi-level queues with feedback  Example: the UNIX scheduler Lecture 203

4. Scheduling – basic concepts Scheduling  assigning jobs to machines. A schedule S  a plan on how to process N jobs using one or machines. Scheduling in the general case in a NP complete problem. A job 1 <= j <- N is characterized by  C i S  completion time of job j under schedule S  p i  processing time  r i  release time; the time when the job is available for processing  d i  due time ; the time when the job should be completed. u i =0 if C i S <= d i and u i =1 otherwise  L j = C i S - d i  lateness A schedule S is characterized by  The makespan C max = max C i S  Average completion time Lecture 204

5. Scheduling objectives Performance metrics:  CPU Utilization  Fraction of time CPU does useful work over total time  Throughput  Number of jobs finished per unit of time  Turnaround time  Time spent by a job in the system  Response time  Time to get the results  Waiting time  Time waiting to start processing All these are random variables  we are interested in averages!! The objectives - system managers (M) and users (U):  Maximize CPU utilization  M  Maximize throughput  M  Minimize turnaround time  U  Minimize waiting time  U  Minimize response time  U 5Lecture 20

6. Scheduling policies Burst time  time required by a thread to use the processor/core Time slice/quantum  time a thread is allowed to use the processor/core Preemptive scheduling  A thread could be forced to release the control of the processor Policies  First-Come First-Serve  FCFS  Shortest Job First  SJF  Round Robin  RR 6Lecture 20

7. First-Come First-Served (FCFS) ThreadBurst Time P 1 24 P 2 3 P 3 3 Processes arrive in the order: P 1  P 2  P 3 Gantt Chart for the schedule: Waiting time for P 1 = 0; P 2 = 24; P 3 = 27 Average waiting time: (0 + 24 + 27)/3 = 17 Convoy effect  short process behind long process P1P1 P2P2 P3P3 2427300 7Lecture 20

8. The effect of the release time on FCFS scheduling Now threads arrive in the order: P 2  P 3  P 1 Gantt chart: Waiting time for P 1 = 6; P 2 = 0 ; P 3 = 3 Average waiting time: (6 + 0 + 3)/3 = 3 Much better!! P1P1 P3P3 P2P2 63300 8Lecture 20

9. Shortest-Job-First (SJF) Use the length of the next burst to schedule the thread/process with the shortest time. SJF is optimal  minimum average waiting time for a given set of threads/processes Two schemes:  Non-preemptive  the thread/process cannot be preempted until completes its burst  Preemptive  if a new thread/process arrives with burst length less than remaining time of current executing process, preempt. known as Shortest-Remaining-Time-First (SRTF) 9Lecture 20

10. Example of non-preemptive SJF ThreadRelease timeBurst Time P 1 0.07 P 2 2.04 P 3 4.01 P 4 5.04 SJF (non-preemptive) Average waiting time = (0 + 6 + 3 + 7)/4 = 4 P1P1 P3P3 P2P2 73160 P4P4 812 10Lecture 20

11. Example of Shortest-Remaining-Time-First (SRTF) (Preemptive SJF) ThreadRelease timeBurst time P 1 0.07 P 2 2.04 P 3 4.01 P 4 5.04 Shortest-Remaining-Time-First Average waiting time = (9 + 1 + 0 +2)/4 = 3 P1P1 P3P3 P2P2 42 11 0 P4P4 57 P2P2 P1P1 16 11Lecture 20

12. Round Robin (RR) Each process gets a small unit of CPU time (time quantum), usually 10-100 milliseconds. After this time has elapsed, the thread/process is preempted and added to the end of the ready queue. If there are n threads/processes in the ready queue and the time quantum is q, then each thread/process gets 1/n of the processor time in chunks of at most q time units at once. No thread/process waits more than (n-1)q time units. Performance  q large  FIFO  q small  q must be large with respect to context switch, otherwise overhead is too high 12Lecture 20

13. RR with time slice q = 20 ThreadBurst Time P 1 53 P 2 17 P 3 68 P 4 24 Typically, higher average turnaround than SJF, but better response P1P1 P2P2 P3P3 P4P4 P1P1 P3P3 P4P4 P1P1 P3P3 P3P3 02037577797117121134154162 13Lecture 20

14. Time slice (quantum) and context switch time 14Lecture 20

15. Turnaround time function of time quantum 15Lecture 20

16. JobRelease time WorkStart timeFinish timeWait time till start Time in system A030303 B1533 + 5 = 83 – 1 = 28 – 1 = 7 C3288 + 2 = 108 – 3 = 510 – 3 = 7 A030303 B1555 + 5 = 10410 – 1 = 9 C3233 + 2 = 505 – 3 = 2 A030606 – 0 = 6 B151101 – 1 = 010 – 1 = 9 C32585 – 3 = 28 – 3 = 5 16Lecture 20

17. Scheduling policy Average waiting time till the job started Average time in system FCFS7/317/3 SJF4/314/3 RR3/320/3 17Lecture 20

18. Priority scheduling Each thread/process has a priority and the one with the highest priority (smallest integer  highest priority) is scheduled next.  Preemptive  Non-preemptive SJF is a priority scheduling where priority is the predicted next CPU burst time Problem  Starvation – low priority threads/processes may never execute Solution to starvation  Aging – as time progresses increase the priority of the thread/process Priority my be computed dynamically 18Lecture 20

19. Priority inversion A lower priority thread/process prevents a higher priority one from running. T 3 has the highest priority, T 1 has the lowest priority; T 1 and T 3 share a lock. T 1 acquires the lock, then it is suspended when T 3 starts. Eventually T 3 requests the lock and it is suspended waiting for T 1 to release the lock. T 2 has higher priority than T 1 and runs; neither T 3 nor T 1 can run; T 1 due to its low priority, T 3 because it needs the lock help by T 1. Allow a low priority thread holding a lock to run with the higher priority of the thread which requests the lock 19Lecture 20