1. Uniprocessor Scheduling
The basic concepts of scheduling apply to many types of systems:
Manufacturing, shipping, network routing
Process and device scheduling in computer systems
Often goals of user friendliness (minimized response time, ease of use, reliability, fairness) conflict with goals of efficiency (maximize mean throughput, minimize mean turnaround time), maximize resource use, as well as of security
Scheduling algorithms also must handle
Boundedness
Specific system goals
Ex: time-constraints for real-time systems
Chapt 9 uniprocessor scheduling

2. Chapt 9 uniprocessor scheduling
Scheduling goals:
General: policy enforcement, enforce priorities, fairness within same priority level
Batch systems: maximum throughput; minimize turnaround time; keep CPU and other components busy
Interactive systems: minimize response time
Hard real-time systems: meet deadlines, satisfy predictability requirements
Chapt 9 uniprocessor scheduling

3. Mix CPU & I/O burst cycles for efficient CPU utilization
Programs have different characteristics
I/O-bound programs (most COBOL, SAS, and transaction processing) have short bursts of CPU time before relinquishing CPU for I/O
CPU-bound programs (computation) have long bursts of CPU time before relinquishing CPU
CPU-bound programs can use CPU while I/O-bound programs are waiting for I/O
Chapt 9 uniprocessor scheduling

4. Non-preemptive scheduling vs preemptive scheduling
Non-preemptive systems
Processor is not taken away from process unless it is relinquished for system call or program error/termination
If I/O interrupt occurs, the ISR returns the CPU to the interrupted process at the end of its interrupt handling
Windows 3.1, 98, Mac OS 5.0
Preemptive systems
Processor is removed if time-quantum expires
Requires timer interrupt
Processor is removed if high priority process arrives or is unblocked
Adds a great deal of complexity to systems
Chapt 9 uniprocessor scheduling

5. Chapt 9 uniprocessor scheduling
Dispatcher
Dispatcher is the kernel process that takes a process from ready state to run state
Handles context switching
Saves state of currently executing process
Restores/ initiates state of new process
Places new user PC in PC register
Stores/ Restores register and other values
Changes mode
Dispatcher runs in supervisor mode
Mode changed to user mode for user processes
Dispatcher execution time must be minimized (dispatch latency)
Motivation for multiple register sets
Chapt 9 uniprocessor scheduling

6. Chapt 9 uniprocessor scheduling
Questions
Is the dispatcher part of the kernel? Why?
Yes. Dispatcher executes for each process allocation to CPU
Should dispatching in a multiprocessing OS be implemented within a (microkernel or portion of) OS running on each processor?
I believe Yes. Each processor in a multiprocessing system should have its own, efficient dispatcher. Where should the dispatch list be?
Chapt 9 uniprocessor scheduling

7. Chapt 9 uniprocessor scheduling
Short-term scheduler
Decides which ready process will be dispatched next
Text says that dispatcher and short-term scheduler are the same process
Typically that is not so
Short-term scheduler decides dispatching order
Dispatcher actually does context switching and mode changes very very quickly
Chapt 9 uniprocessor scheduling

8. Medium-term scheduler
Decides which (and when) processes should be made non-resident, or swapped back into memory
Only required when too many processes are in a state of execution
Chapt 9 uniprocessor scheduling

9. Chapt 9 uniprocessor scheduling
Long term scheduler
Decides when and which programs to be made into processes
Controls the degree of multiprogramming
In batch multiprogramming systems, decides
Whether to accept more processes from batch spool
Which of the processes to accept based on scheduling goals
In time-sharing system, accepts all arriving processes up to a limit (then must deny others a connection)
Chapt 9 uniprocessor scheduling

10. Scheduling Algorithms
We consider several scheduling algorithms in discussing goals of priority, shortest waiting time, fairness
The following processes are all available at scheduling time:
Process Service Time W X Y Z
Chapt 9 uniprocessor scheduling

11. FCFS Scheduling Algorithms
Gantt charts
FCFS (non-preemptive)
W X Y Z ms
Mean response time is ( )/4= 81/4 =20 ms;
Mean turnaround time is ( )/4 = 30 ms
Normalized turnaround time (ratio of turnaround time to service time) for W = 24/24= 1; X = 27/3= 9; Y = 30/3= 10; Z = 38/8= 4.5
Increasing values indicate decreasing level of service
Chapt 9 uniprocessor scheduling

12. FCFS with different arrival times
Chapt 9 uniprocessor scheduling

13. First-Come-First-Served
Each process joins the Ready queue
When the current process ceases to execute, the process that has been in the Ready queue the longest is selected
Mean response time (how long each is waiting on average) = (0 + (3-2) + (9-4)+ (13-6) + (18-8))/5 = 23/5 = 4.6
Mean turnaround time = (3 + (9-2) + (13-4) + (18-6) + (20-8))/5 = 43/5 = 8.6
As each process becomes ready, it joins the ready queue.
When the currently running process ceases to execute, the process that has been in the ready queue the longest is selected for running.

14. Shortest Process Next (SPN)
Processes must state their total (or burst) service needs
This example is non-preemptive
Preemptive type is considered later
A [0-3] B [3-9] E [9-11] C[11-15] D [15-20]
Mean turnaround time =
(3 + (9-2) + (15-4) + (20-6) + (11-8))/5 = 7.6
Mean Normalized Turnaround time =
((3/3+ 7/6 + 11/4 + 14/5 + 3/2))/5 =1.84
Only A is available at time 0.Only B is available at time 3.
Chapt 9 uniprocessor scheduling

15. Chapt 9 uniprocessor scheduling
Shortest Process Next
A__B___E__C____D_____
Mean turnaround time
A finishes at 3 and starts at 0
((3-0) + (9-2) + (15-4) + (20-6) + (11-8))/5 = 7.6
Mean Normalized Turnaround time =
((3/3+ (9-2)/6 + (15-4)/4 + (20-6)/5 + 3/2))/5 =1.84
Chapt 9 uniprocessor scheduling

16. FCFS/SPN Scheduling Algorithms - Issues
(Non-preemptive )FCFS
If long process (P1) is first, it hogs CPU; devices stay idle
Poor response time for later processes
Not appropriate for real-time systems
Preemptive or non-preemptive SPN (shortest process next)
Provides minimal average waiting time
Yet if short jobs get CPU first, they may all compete for devices
many requests to DMA slow down the CPU
How do we estimate which is the shortest job?
Batch systems may require that users pre-state CPU needs
Scheduler may estimate by process history
But process behavior may change (between CPU and I/O)
If SPN is preemptive, time slices help us in estimate
Chapt 9 uniprocessor scheduling

17. Shortest Remaining Time (SRT)
Preemptive SPN- prestate needs
Assume 1 unit time quantum (q =1)
A[0-3]B[3-4]C [4-8] E[8-10] B[10-15]D[15-20]
A__B_C__E___B___D__
Mean turnaround time =
(3 + (15-2) + (8-4) + (20-6) + (10-8))/5 = 7.2
Mean Normalized Turnaround time =
((3/3+ 13/6 + 4/4 + 14/5 + 2/2))/5 =1.593
A is the only process available at 0. Even if B required only 1 unit, A would not be preempted – it only needs 1 unit more.
Note that this is better than SPN if context switching is minimal. Still it requires processes to prestate their needs.
Chapt 9 uniprocessor scheduling

18. Round Robin Scheduling
Preemptive form of FCFS
Requires timing interrupt support
A time slice is chosen for a process’s maximum burst (how long the process can hold CPU)
If process exceeds time slice, the processor is forcibly removed
If it surrenders early (perhaps for an I/O), processor is allocated to another process
Chapt 9 uniprocessor scheduling

19. Round-robin time quantum
What should the time quantum be?
Turnaround time suffers and efficiency suffers if time quantum is too low
Becomes (non-preemptive) FCFS if time quantum is too large (with longer average response times)
80% of CPU bursts should be < time quantum
Still, CPU-bound jobs get more of the CPU than I/O- bound jobs
Inefficient use of devices
Increased variance of response time dependent on job mix
Chapt 9 uniprocessor scheduling

20. Round Robin Uses preemption based on a clock
also known as time slicing, because each process is given a slice of time before being preempted.
A straightforward way to reduce the penalty that short jobs suffer with FCFS is to use preemption based on a clock.
The simplest such policy is round robin.
Also known as time slicing, because each process is given a slice of time before being preempted.

21. Chapt 9 uniprocessor scheduling
Round Robin
A’s turnaround time is 4.
A’s Normalized is 4/3 = 1.3
B’s turnaround time is (18-2). Normalized is 16/6 = 2.7
C’s turnaround time is (17-4). Normalized is 13/4 = 3.25
D’s turnaround time is (20-6). Normalized is 14/5 = 2.8
E’s turnaround time is (15-8) Normalized is 7/2 = 3.5
Newly arrived process is placed on queue before preempted/suspended process
Chapt 9 uniprocessor scheduling

22. Chapt 9 uniprocessor scheduling
Priority Queuing
Scheduling with prioritized queues
Lower-priority processes may never be scheduled (starve)
We can raise their priorities dynamically by waiting time
Called aging
Static priorities typically MUST be scheduled by priority assignment
Chapt 9 uniprocessor scheduling

23. Types of Priority Scheduling
Internal priorities
High priority assigned to I/O bound jobs
expected to complete service quickly
Memory and file needs or allocation may affect priority
External priorities
Real-time needs
President of company
Premium service classes
Console operator decides to boost or lower priorities
Dynamic or static priority assignments
Indefinite blocking (starvation) is enabled
Controlled by increasing priority by waiting time (aging)
Chapt 9 uniprocessor scheduling

24. Chapt 9 uniprocessor scheduling
Priority Scheduling
Assume low values are higher priority. Preemption can occur after each time slice of 2 ms. (In case of a tie, use FCFS)
arrives burst priority
P ms ms
P ms
P ms
P ms
P1 P3 P P P2
Average turnaround time ((15-0)+(18-1) + (4-2) +(7-3))/4 = 9.5 ms
Chapt 9 uniprocessor scheduling

25. Multilevel feedback queues (DEC VMS)
Top 16 queues for systems processes scheduled by priority interrupts
Real-time needs
These are fast and non-preemptive
Each queue uses FCFS
Next 13 RR queues are for priority time-sharing processes
Process is placed at the end of higher priority queue if it behaves well (relinquishes CPU voluntarily)
Process placed at end of lower queue if CPU forcibly removed
Batch jobs on bottom 3 queues – FCFS (starvation possible)
Larger time quanta assigned to lower RR queues
Chapt 9 uniprocessor scheduling

26. Fair-Share Scheduling
System keeps track of number of processes (or threads) of a group to estimate how often each process (thread) gets a turn
Good for scheduling threads mapped to kernel threads
Different schemes exist but typically include factors of static thread priority, thread processor use; group processor use
Chapt 9 uniprocessor scheduling

27. Chapt 9 uniprocessor scheduling
Real-Time Scheduling
Soft real-time
Multimedia, interactive graphics
Priority scheduling
System calls may be preempted
Must, however, protect shared data
Hard real-time processes are assigned priorities based on their time constraints (preemptive scheduling)
System must decide # of levels and how to assign priorities
May be interrupt driven based on priorities
If scheduling is required, processes prestate CPU needs (resource reservation) so that system can guarantee time constraints
Scheduling function must have minimal overhead
Chapt 9 uniprocessor scheduling