1. Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition, Chapter 5: CPU Scheduling

2. 5.2 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Outline n Basic Concepts n Scheduling Criteria n Scheduling Algorithms n Thread Scheduling n Multiple-Processor Scheduling n OS Examples n Algorithm Evaluation

3. 5.3 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Objectives n To introduce CPU scheduling, which is the basis for multiprogrammed OS n To describe various CPU-scheduling algorithms n To discuss evaluation criteria for selecting a CPU- scheduling algorithm for a particular system

4. 5.4 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Basic Concepts n Maximum CPU utilization obtained with multiprogramming n CPU–I/O Burst Cycle l Process execution consists of a cycle of CPU execution and I/O wait n CPU burst distribution

5. 5.5 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Histogram of CPU-burst Times

6. 5.6 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Alternating Sequence of CPU and I/O Bursts

7. 5.7 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition CPU Scheduler n Selects from among the processes in memory that are ready to execute, and allocates the CPU to one of them n 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 n Scheduling only under 1 and 4 is nonpreemptive n All other scheduling is preemptive

8. 5.8 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Dispatcher n Dispatcher module gives CPU control to the process selected by the short-term scheduler; this involves: l switching context l switching to user mode l jumping to the proper location in the user program to restart that program n Dispatch latency – time it takes for the dispatcher to stop one process and start another running

9. 5.9 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Scheduling Criteria n CPU utilization – keep the CPU as busy as possible n Throughput – # of processes that complete their execution per time unit n Turnaround time – amount of time to execute a particular process n Waiting time – amount of time a process has been waiting in the ready queue n 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)

10. 5.10 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Scheduling Algorithm Optimization Criteria n Max CPU utilization n Max throughput n Min turnaround time n Min waiting time n Min response time

11. 5.11 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition First-Come, First-Served (FCFS) Scheduling ProcessBurst Time P 1 24 P 2 3 P 3 3 n Suppose that the processes arrive in the order: P 1, P 2, P 3 The Gantt Chart for the schedule is: n Waiting time for P 1 = 0; P 2 = 24; P 3 = 27 n Average waiting time: (0 + 24 + 27)/3 = 17 P1P1 P2P2 P3P3 2427300

12. 5.12 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition FCFS Scheduling (Cont) Suppose that the processes arrive in the order P 2, P 3, P 1 n The Gantt chart for the schedule is: n Waiting time for P 1 = 6 ; P 2 = 0 ; P 3 = 3 n Average waiting time: (6 + 0 + 3)/3 = 3 l Much better than previous case n Convoy effect: short process behind long process P1P1 P3P3 P2P2 63300

13. 5.13 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Shortest-Job-First (SJF) Scheduling n Associate with each process the length of its next CPU burst l to schedule the process with the shortest time n SJF is optimal – gives minimum average waiting time for a given set of processes l The difficulty is knowing the length of the next CPU request

14. 5.14 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Example of SJF ProcessBurst Time P 1 6 P 2 8 P 3 7 P 4 3 n SJF scheduling chart n Average waiting time = (3 + 16 + 9 + 0) / 4 = 7 P4P4 P3P3 P1P1 3 16 0 9 P2P2 24

15. 5.15 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Determining Length of Next CPU Burst n Can only estimate the length n Can be done by using the length of previous CPU bursts, using exponential averaging

16. 5.16 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Prediction of the Length of the Next CPU Burst

17. 5.17 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Examples of Exponential Averaging n  = 0 l  n+1 =  n l Recent history does not count n  = 1 l  n+1 =  t n l Only the actual last CPU burst counts n If we expand the formula, we get:  n +1 =  t n +(1 -  )  t n -1 + … +( 1 -  ) j  t n - j + … +( 1 -  ) n +1  0 n Since both  and (1 -  ) are less than or equal to 1, each successive term has less weight than its predecessor

18. 5.18 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Priority Scheduling n A priority number (integer) is associated with each process n The CPU is allocated to the process with the highest priority (smallest integer  highest priority) l Preemptive l Nonpreemptive n SJF is a priority scheduling where priority is the predicted next CPU burst time n Problem  Starvation – low priority processes may never execute n Solution  Aging – as time progresses increase the priority of the process

19. 5.19 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Round Robin (RR) n Each process gets a small unit of CPU time ( time quantum ), usually 10-100 milliseconds l After this time has elapsed, the process is preempted and added to the end of the ready queue n 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 l No process waits more than ( n -1) q time units n Performance l q large  FCFS l q small  q must be large with respect to context switch, otherwise overhead is too high

20. 5.20 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Example of RR with Time Quantum = 4 ProcessBurst Time P 1 24 P 2 3 P 3 3 n The Gantt chart is: n Typically, higher average turnaround than SJF, but better response P1P1 P2P2 P3P3 P1P1 P1P1 P1P1 P1P1 P1P1 0 47 101418222630

21. 5.21 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Time Quantum and Context Switch Time

22. 5.22 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Turnaround Time Varies with the Time Quantum

23. 5.23 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Multilevel Queue n Ready queue is partitioned into separate queues: foreground (interactive) background (batch) n Each queue has its own scheduling algorithm l foreground – RR l background – FCFS n Scheduling must be done among the queues l Fixed priority scheduling: to serve all from foreground then from background  Possibility of starvation l Time slice – each queue gets a certain amount of CPU time which it can schedule amongst its processes  i.e., 80% to foreground in RR, 20% to background in FCFS

24. 5.24 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Multilevel Queue Scheduling

25. 5.25 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Multilevel Feedback Queue n A process can move between various queues; aging can be implemented this way n Multilevel-feedback-queue scheduler defined by the following parameters: l number of queues l scheduling algorithms for each queue l method used to determine when to upgrade a process l method used to determine when to demote a process l method used to determine which queue a process will enter when that process needs service

26. 5.26 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Example of Multilevel Feedback Queue n Three queues: l Q 0 – RR with time quantum 8 milliseconds l Q 1 – RR with time quantum 16 milliseconds l Q 2 – FCFS n Scheduling l A new job enters queue Q 0 which is served FCFS  When it gains CPU, job receives 8 milliseconds  If it does not finish in 8 milliseconds, job is moved to queue Q 1 l At Q 1 job is again served FCFS and receives 16 additional milliseconds  If it still does not complete, it is preempted and moved to queue Q 2

27. 5.27 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Multilevel Feedback Queues

28. 5.28 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Thread Scheduling n Distinction between user-level and kernel-level threads n Many-to-one and many-to-many models, thread library schedules user-level threads to run on LWP l Known as process-contention scope (PCS) since scheduling competition is within the process n Kernel thread scheduled onto available CPU is system-contention scope (SCS) – competition among all threads in system

29. 5.29 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Pthread Scheduling n API allows specifying either PCS or SCS during thread creation l PTHREAD_SCOPE_PROCESS schedules threads using PCS scheduling l PTHREAD_SCOPE_SYSTEM schedules threads using SCS scheduling

30. 5.30 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Pthread Scheduling API (Fig. 5.8) #include #define NUM_THREADS 5 int main(int argc, char *argv[]) { int i; pthread t tid[NUM_THREADS]; pthread_attr t_attr; /* get the default attributes */ pthread_attr_init(&attr); /* set the scheduling algorithm to PROCESS or SYSTEM*/ pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM); /* set the scheduling policy - FIFO, RT, or OTHER */ pthread_attr_setschedpolicy(&attr, SCHED_OTHER);

31. 5.31 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Pthread Scheduling API /* create the threads */ for (i = 0; i < NUM_THREADS; i++) pthread_create(&tid[i],&attr,runner,NULL); /* now join on each thread */ for (i = 0; i < NUM_THREADS; i++) pthread_join(tid[i], NULL); } /* Each thread will begin control in this function */ void *runner(void *param) { printf("I am a thread\n"); pthread_exit(0); }

32. 5.32 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Multiple-Processor Scheduling n CPU scheduling more complex when multiple CPUs are available l Homogeneous processors within a multiprocessor n Approach l Asymmetric multiprocessing – only one processor accesses the system data structures, alleviating the need for data sharing l Symmetric multiprocessing (SMP) – each processor is self-scheduling, all processes in common ready queue, or each has its own private queue of ready processes n Processor affinity – process has affinity for processor on which it is currently running l soft affinity l hard affinity

33. 5.33 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition NUMA and CPU Scheduling NUMA: Non-Uniform Memory Access

34. 5.34 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Multicore Processors n Recent trend to place multiple processor cores on same physical chip l Faster and consume less power n Multiple hardware threads per core also growing l Takes advantage of memory stall to make progress on another thread while memory retrieve happens

35. 5.35 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Multithreaded Multicore System

36. 5.36 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition OS Examples n Solaris scheduling n Windows XP scheduling n Linux scheduling

37. 5.37 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Solaris Dispatch Table

38. 5.38 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Solaris Scheduling

39. 5.39 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Windows XP Priorities Priority Classes Relative Priority

40. 5.40 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Linux Scheduling n Constant order O (1) scheduling time l After kernel version 2.5 n Two priority ranges: time-sharing and real-time l Real-time range from 0 to 99 l Nice value from 100 to 140

41. 5.41 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Priorities and Time-slice Length (Fig. 5.15)

42. 5.42 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition List of Tasks Indexed According to Priorities

43. 5.43 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Algorithm Evaluation n Deterministic modeling – takes a particular predetermined workload and defines the performance of each algorithm for that workload l Simple and fast l Answers only apply to the cases n Queueing models l Classes of algorithms and distributions are limited n Simulations l Programming a model of the system l Expensive n Implementation l High cost for coding and modifying the OS

44. 5.44 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Evaluation of CPU Schedulers by Simulation

45. Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition, End of Chapter 5

46. 5.46 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition 5.08

47. 5.47 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition In-5.7

48. 5.48 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition In-5.8

49. 5.49 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition In-5.9

50. 5.50 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Dispatch Latency

51. 5.51 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Java Thread Scheduling n JVM Uses a Preemptive, Priority-Based Scheduling Algorithm n FIFO Queue is Used if There Are Multiple Threads With the Same Priority

52. 5.52 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Java Thread Scheduling (cont) JVM Schedules a Thread to Run When: 1. The Currently Running Thread Exits the Runnable State 2. A Higher Priority Thread Enters the Runnable State * Note – the JVM Does Not Specify Whether Threads are Time-Sliced or Not

53. 5.53 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Time-Slicing Since the JVM Doesn’t Ensure Time-Slicing, the yield() Method May Be Used: while (true) { // perform CPU-intensive task... Thread.yield(); } This Yields Control to Another Thread of Equal Priority

54. 5.54 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Thread Priorities PriorityComment Thread.MIN_PRIORITYMinimum Thread Priority Thread.MAX_PRIORITY Maximum Thread Priority Thread.NORM_PRIORITY Default Thread Priority Priorities May Be Set Using setPriority() method: setPriority(Thread.NORM_PRIORITY + 2);

55. 5.55 Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Solaris 2 Scheduling