1 / 24

Process Switch in Operating Systems

Learn about process switching in operating systems, including the context switch and its overheads. Explore different scheduling algorithms like FCFS, SJF, and RR with examples.

kathleenhamilton
Download Presentation

Process Switch in Operating Systems

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Operating SystemsCMPSC 473 Processes (contd.) September 01, 2010 - Lecture 4 Instructor: Bhuvan Urgaonkar

  2. Process Switch • Suspend the current process and resume a previously suspended process • Also called context switch or task switch

  3. A1 A2 Process Switch Involuntary/Voluntary Process 1 Process 0 Context_switch() { } B1 B2 B3 B4

  4. Process Switch • What does the kernel need to save when suspending a process? • Hint: The entire address space is already saved (either in memory or on swap space). What else would the process need when it has to be resumed? • CPU registers • This is called the hardware context of the process • Execution context, PC, pointers to elements within address space, page table, etc.

  5. Context_switch() { push R0, R1, … // save regs on its stack PCB[curr].SP = SP // save stack pointer PCB[curr].PT = PT // save ptr(s) to address space next = schedule() // find next process to run PT = PCB[next].PT SP = PCB[next].SP pop Rn, … R0 return // NOTE: Ctrl returns to another process }

  6. Overheads of Process Switch • Direct • The time spent switching context • Indirect • Cache pollution • TLB flush

  7. CPU Scheduling

  8. Process Scheduling Hmm .. Who should I pick to run? Running OS (scheduler) Ready Lock Waiting Disk

  9. When is the scheduler invoked? • CPU scheduling decisions may take place when a process: • 1. Switches from running to waiting state • 2. Switches from running to ready state • 3. Switches from waiting to ready • 4. Terminates • Scheduling only under 1 and 4: nonpreemptive scheduling • E.g., FCFS and SJF • All other scheduling is preemptive

  10. P1 P2 P3 0 24 27 30 First-Come, First-Served Scheduling(FCFS) Process Run Time P1 24 P2 3 P3 3 • Suppose that the processes arrive in the order: P1 , P2 , P3 The Gantt Chart for the schedule is: • Waiting time for P1 = 0; P2 = 24; P3 = 27 • Average waiting time: (0 + 24 + 27)/3 = 17

  11. P2 P3 P1 0 3 6 30 FCFS Scheduling (Cont.) Suppose that the processes arrive in the order P2 , P3 , P1 • The Gantt chart for the schedule is: • Waiting time for P1 = 6;P2 = 0; P3 = 3 • Average waiting time: (6 + 0 + 3)/3 = 3 • Much better than previous case • Convoy effect short process behind long process

  12. Choosing the Right Scheduling Algorithm/Scheduling Criteria • CPU utilization – keep the CPU as busy as possible • Throughput – # of processes that complete their execution per time unit • Turnaround time – amount of time to execute a particular process • Waiting time – amount of time a process has been waiting in the ready queue • Response time – amount of time it takes from when a request was submitted until the first response is produced, not output (for time-sharing environment) • Fairness

  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 • SJF is optimal for avg. waiting time – gives minimum average waiting time for a given set of processes • In class: Compute average waiting time for the previous example with SJF • Exercise: Prove the optimality claimed above

  14. Why Pre-emption is Necessary • To improve CPU utilization • Most processes are not ready at all times during their lifetimes • E.g., think of a text editor waiting for input from the keyboard • Also improves I/O utilization • To improve responsiveness • Many processes would prefer “slow but steady progress” over “long wait followed by fast process” • Most modern CPU schedulers are pre-emptive

  15. SJF: Variations on the theme • Non-preemptive: once CPU given to the process it cannot be • preempted until completes its CPU burst - the SJF we already saw • Preemptive: if a new process arrives with CPU length less • than remaining time of current executing process, preempt. • This scheme is know as Shortest-Remaining-Time-First (SRTF) • Also called Shortest Remaining Processing Time (SRPT) • Why SJF/SRTF may not be practical • CPU requirement of a process rarely known in advance

  16. Round Robin (RR) • Each process gets a small unit of CPU time (time quantum), usually 10-100 milliseconds. After this time has elapsed, the process is 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 large => FCFS • q small => q must be large with respect to context switch, otherwise overhead is too high

  17. P1 P2 P3 P4 P1 P3 P4 P1 P3 P3 0 20 37 57 77 97 117 121 134 154 162 Example of RR with Time Quantum = 20 ProcessCPU Time P1 53 P2 17 P3 68 P4 24 • The Gantt chart is: • Typically, higher average turnaround than SJF, but better response

  18. Time Quantum and Context Switch Time

  19. Turnaround Time Varies With Time Quantum

  20. Proportional-Share Schedulers • A generalization of round robin • Process Pi given a CPU weight wi > 0 • The scheduler needs to ensure the following • forall i, j, |Ti(t1, t2)/Tj(t1,t2) - wi/wj| ≤ e • Given Pi and Pj were backlogged during [t1,t2] • Who chooses the weights and how? • Application modeling problem: non-trivial • Many PS schedulers developed in the 90s • E.g., Start-time Fair Queueing (Qlinux UT-Austin/Umass-Amherst)

  21. Lottery Scheduling[Carl Waldspurger, MIT, ~1995] • Perhaps the simplest proportional-share scheduler • Create lottery tickets equal to the sum of the weights of all processes • What if the weights are non-integral? • Draw a lottery ticket and schedule the process that owns that ticket • What if the process is not ready? • Draw tickets only for ready processes • Exercise: Calculate the time/space complexity of the operations Lottery scheduling will involve

  22. Lottery Scheduling Example P1=6 P2=9 1 4 7 10 13 2 5 8 11 14 3 6 9 12 15 9 Schedule P2

  23. Lottery Scheduling Example P1=6 P2=9 1 4 7 10 13 2 5 8 11 14 3 6 9 12 15 3 Schedule P1

  24. Lottery Scheduling Example P1=6 P2=9 1 4 7 10 13 • As t ∞, processes will get their share (unless they were blocked a lot) • Problem with Lottery scheduling: Only probabilistic guarantee • What does the scheduler have to do • When a new process arrives? • When a process terminates? 2 5 8 11 14 3 6 9 12 15 11 Schedule P2

More Related