Algorithm o.s.
1 like1,907 views
This document outlines scheduling algorithms. It begins with an introduction and overview, then discusses key concepts like processes, process states, and scheduling criteria. It proceeds to explain common scheduling algorithms like FCFS, SJF, priority scheduling, and round robin. It concludes by covering more advanced topics such as multi-level queue scheduling, multi-processor scheduling, and load balancing.
Ad
More Related Content
What's hot (20)
Similar to Algorithm o.s. (20)
Ad
More from Mohd Tousif (20)
Ad
Recently uploaded (20)
Algorithm o.s.
- 1. Scheduling Algorithms Frédéric Haziza <[email protected]> Department of Computer Systems Uppsala University Spring 2007
- 2. Recall Basics Algorithms Multi-Processor Scheduling Outline 1 Recall 2 Basics Concepts Criteria 3 Algorithms 4 Multi-Processor Scheduling
- 3. Recall Basics Algorithms Multi-Processor Scheduling Interrupts Traps (software errors, illegal instructions) System calls
- 4. Recall Basics Algorithms Multi-Processor Scheduling PCB Job Queue process state Linked list of PCBs process ID (number) PC (main) job queue Registers memory information ready queue open files device queues . . . Schedulers other resources Long-term/Job scheduler (loads from disk) Short-term/CPU scheduler (dispatches from ready queue)
- 5. Recall Basics Algorithms Multi-Processor Scheduling Note that... On Operating Systems which support threads, it is kernel-level threads – not processes – that are being scheduled. However, process sheduling ≈ thread scheduling.
- 6. Recall Basics Algorithms Multi-Processor Scheduling CPU and IO Bursts . . . load, store, add, store, read from file Wait for IO store,increment, branch, write to file Wait for IO CPU Burst cycles load, store, Intervals with no I/O usage read from file Wait for IO Waiting time . . . Sum of time waiting in ready queue
- 7. Recall Basics Algorithms Multi-Processor Scheduling When should we schedule a process? From running state to waiting state From running state to ready state From waiting state to ready state Terminates Scheme Scheme non-preemptive preemptive or cooperative
- 8. Recall Basics Algorithms Multi-Processor Scheduling How do we select the next process? CPU utilization CPU as busy as possible Throughput Number of process that are completed per time unit Turnaround time Time between submisson and completion Waiting time Scheduling affects only waiting time Response time Time between submisson and first response
- 9. Recall Basics Algorithms Multi-Processor Scheduling First Come, First Served (FCFS) Non-preemptive Treats ready queue as FIFO. Simple, but typically long/varying waiting time.
- 10. Recall Basics Algorithms Multi-Processor Scheduling First Come, First Served (FCFS) Example Process Burst time Arrival P1 24 0 P2 3 0 P3 3 0 Gantt chart: Order P1 , P2 , P3 | P1 | P2 | P3 | 0 24 27 30 Average waiting time: (0+24+27)/3 = 17
- 11. Recall Basics Algorithms Multi-Processor Scheduling First Come, First Served (FCFS) Example Process Burst time Arrival P1 24 0 P2 3 0 P3 3 0 Gantt chart: Order P2 , P3 , P1 | P2 | P3 | P1 | 0 3 6 30 Average waiting time: (0+3+6)/3 = 3
- 12. Recall Basics Algorithms Multi-Processor Scheduling Convoy effect Consider : P1 : CPU-bound P2 , P3 , P4 : I/O-bound
- 13. Recall Basics Algorithms Multi-Processor Scheduling Convoy effect P2 , P3 and P4 could quickly finish their IO request ⇒ ready queue, waiting for CPU. Note: IO devices are idle then. then P1 finishes its CPU burst and move to an IO device. P2 , P3 , P4 , which have short CPU bursts, finish quickly ⇒ back to IO queue. Note: CPU is idle then. P1 moves then back to ready queue is gets allocated CPU time. Again P2 , P3 , P4 wait behind P1 when they request CPU time. One cause: FCFS is non-preemptive P1 keeps the CPU as long as it needs
- 14. Recall Basics Algorithms Multi-Processor Scheduling Shortest Job First (SJF) Give CPU to the process with the shortest next burst If equal, use FCFS Better name: shortest next cpu burst first Assumption Know the length of the next CPU burst of each process in Ready Queue
- 15. Recall Basics Algorithms Multi-Processor Scheduling Short Job First (SJF) Example Process Burst time Arrival P1 6 0 P2 8 0 P3 7 0 P4 3 0 Gantt chart: Order P1 , P2 , P3 , P4 | P4 | P1 | P3 | P2 | 0 3 9 16 24 Average waiting time: (0+3+16+9)/4 = 7 With FCFS: (0+6+(6+8)+(6+8+7))/4 = 10.25
- 16. Recall Basics Algorithms Multi-Processor Scheduling SJF – Characteristics Optimal wrt. waiting time! Problem: how to know the next burst? User specifies (e.g. for batch system) Guess/predict based on earlier bursts, using exponential average: τn+1 = αtn + (1 − α)τn tn : most recent information τn : past history Can be preemptive or not
- 17. Recall Basics Algorithms Multi-Processor Scheduling SJF with Preemption Shortest Remaining Time First When a process arrives to RQ, sort it in and select the SJF including the running process, possibly interrupting it (Remember: SJF schedules a new process only when the running is finished)
- 18. Recall Basics Algorithms Multi-Processor Scheduling SJF with Preemption Example Process Burst time Arrival P1 8 0 P2 4 1 P3 9 2 P4 5 3 Gantt chart | P1 | P2 | P4 | P1 | P3 | 0 1 5 10 17 26 Average waiting time: ((10-1)+(1-1)+(17-2)+(5-3))/4 = 6.5 With SJF: (0+4+(4+5)+(4+5+8))/4 = 7.75
- 19. Recall Basics Algorithms Multi-Processor Scheduling Priority Scheduling Algorithms Priority associated with each process CPU allocated to the process with highest priority If equal, use FCFS Note: SJF is a priority scheduling algorithm with 1 p = (predicted) next CPU burst
- 20. Recall Basics Algorithms Multi-Processor Scheduling Priority Scheduling Algorithms Example Process Burst time Arrival Priority P1 10 0 3 P2 1 0 1 P3 2 0 4 P4 1 0 5 P5 5 0 2 Gantt chart | P2 | P5 | P1 | P3 | P4 | 0 1 6 16 18 19 Average waiting time: (0+1+6+16+18)/5 = 8.2
- 21. Recall Basics Algorithms Multi-Processor Scheduling Priority Criteria Internal Priority time limits, mem requirements, number of open files, ratio Average CPUburst Average IO burst External Priority Critera outside the OS. Choice related to computer usage. Can be preemptive or not Problem: Starvation (or Indefinite Blocking) Solution: Aging
- 22. Recall Basics Algorithms Multi-Processor Scheduling Round-Robin (RR) FCFS with Preemption Time quantum (or time slice) Ready Queue treated as circular queue
- 23. Recall Basics Algorithms Multi-Processor Scheduling Round-Robin (RR) Example Process Burst time Arrival P1 24 0 Quantum q = 4 P2 3 0 P3 3 0 Gantt chart | P1 | P2 | P3 | P1 | ... | P1 | 0 4 7 10 14 26 30 Average waiting time: (0+4+7+(10-4))/3 = 5.66 With FCFS: (0+24+27)/3 = 17
- 24. Recall Basics Algorithms Multi-Processor Scheduling RR – Characteristics Turnaround time typically larger than SRTF but better response time Performance depends on quantum q Small q: Overhead due to context switches (& scheduling) q should be large wrt context-switching time Large q: Behaves like FCFS rule of thumb: 80% of bursts should be shorter than q (also improves turnaround time)
- 25. Recall Basics Algorithms Multi-Processor Scheduling Multilevel Queue Scheduling Observation Different algorithms suit different types of processes (e.g. interactive vs batch/background processes) and systems are often not only running interactive or "batch" processes. Multilevel queues We split the Ready Queue in several queues, each with its own scheduling algorithm Example interactive processes: RR background processes: FCFS/SRTF
- 26. Recall Basics Algorithms Multi-Processor Scheduling Multilevel Queue – Scheduling among Queues One more dimension We need scheduling between the Ready Queues Example (Common implementation) Fixed-priority preemption (with priority to interactive processes)
- 27. Recall Basics Algorithms Multi-Processor Scheduling Multilevel Queue – More complex example 1 System processes where each queue has absolute priority over 2 Interactive processes lower-priority queues. 3 Interactive editing processes No process in low-priority queues can run if 4 Batch processes high-priority queues are not empty 5 Student processes So, if a lower-priority queue is only used when all higher-priority RQs are empty & higher-priority processes preempt lower-priority ones, we risk starvation. Possible solution: give time-slices to each Ready Queue (basically RR between the queues, with different quanta for each queue) ⇒ Each queue gets a certain guaranteed slice of the CPU time.
- 28. Recall Basics Algorithms Multi-Processor Scheduling Multi-Level Feedback Queue Scheduling (MLFQ) With MLQ, each process is permanently assigned to one queue (based on type, priority etc). MLFQ allow processes to move between queues Idea: Separate processes according to their CPU bursts. Example Let processes with long CPU bursts move down in the queue levels Leave I/O bound and interactive processes in high-priority queues Combine with aging principle to prevent starvation
- 29. Recall Basics Algorithms Multi-Processor Scheduling MLFQ – Example 1 Round-Robin with quantum 8 2 Round-Robin with quantum 16 3 FCFS Qi has priority over, and preempts, Qi+1 . New processes are added to Q1 . If a process in Q1 or Q2 does not finish within its quantum, it is moved down to the next queue. Thus: short bursts (I/O bound and interactive proc) are served quickly; slightly longer are also served quickly but with less priority; long (CPU bound processes) are served when there is CPU to be spared.
- 30. Recall Basics Algorithms Multi-Processor Scheduling Symmetry / Asymmetry Asymmetric MPs scheduling One Master Server does all scheduling. Others execute only user code Symmetric MPs (SMP) scheduling Each processor does scheduling. (whether CPUs have a common or private Ready Queues)
- 31. Recall Basics Algorithms Multi-Processor Scheduling Processor Affinity Try to keep a process on the same processor as last time, because of Geographical Locality (Moving the process to another CPU causes cache misses) Soft affinity The process may move to another processor Hard affinity The process must stay on the same processor
- 32. Recall Basics Algorithms Multi-Processor Scheduling Load Balancing Keep the workload evenly distributed over the processors push migration periodically check the load, and "push" processes to less loaded queues. pull migration idle processors "pull" processes from busy processors Note: Load balancing goes against processor affinity.
- 33. Recall Basics Algorithms Multi-Processor Scheduling Hyperthreaded CPUs CPUs with multiple "cores" Sharing cache and bus influences affinity concept and thus scheduling. The OS can view each core as a CPU, but can make additional benefits with threads