Lecture Topics: 11/15

CPU scheduling:
Scheduling goals and algorithms

Review: Process State

A process can be in one of several states (new, ready, running, waiting, terminated). The OS keeps track of process state by maintaining a queue of PCBs for each state. The ready queue contains PCBs of processes that are waiting to be assigned to the CPU.

The Scheduling Problem

Need to share the CPU between multiple processes in the ready queue.
OS needs to decide which process gets the CPU next. Once a process is selected, OS needs to do some work to get the process running on the CPU.

How Scheduling Works

The scheduler is responsible for choosing a process from the ready queue. The scheduling algorithm implemented by this module determines how process selection is done. The scheduler hands the selected process off to the dispatcher which gives the process control of the CPU.

When Does The OS Make Scheduling Decisions ?

Scheduling decisions are always made:
when a process is terminated, and when a process switches from running to waiting.

Scheduling decisions are made when an interrupt occurs only in a preemptive system.

How is the CPU Shared?

Non-preemptive scheduling:
The scheduler must wait for a running process to voluntarily relinquish the CPU (process either terminates or blocks). Why would you choose this approach? What are the disadvantages of using this scheme?

How is the CPU Shared?

Preemptive scheduling:
The OS can force a running process to give up control of the CPU, allowing the scheduler to pick another process. What are the advantages of using this scheme? What are the implementation challenges presented by this approach?

Scheduling Goals
Maximize throughput and resource utilization.
Need to overlap CPU and I/O activities.

Minimize response time, waiting time and turnaround time. Share CPU in a fair way. May be difficult to meet all these goals-sometimes need to make tradeoffs.

CPU and I/O Bursts

Typical process execution pattern: use the CPU for a while (CPU burst), then do some I/O operations (IO burst). CPU bound processes perform I/O operations infrequently and tend to have long CPU bursts. I/O bound processes spend less time doing computation and tend to have short CPU bursts.

Scheduling Algorithms
First Come First Served (FCFS)
Scheduler selects the process at the head of the ready queue; typically nonpreemptive Example: 3 processes arrive at the ready queue in the following order:
P1 ( CPU burst = 24 ms) P2 ( CPU burst = 3 ms) P3 ( CPU burst = 3 ms)

Scheduling Algorithms
First Come First Served (FCFS)
Example: Whats the average waiting time?

FCFS pros & cons:

+Simple to implement. Average waiting time can be large if processes with short CPU bursts get stuck behind processes with long CPU bursts.

Scheduling Algorithms
Round Robin (RR)
FCFS + preemptive scheduling. Ready queue is treated as a circular queue. Each process gets the CPU for a time quantum (or time slice), typically 10 - 100 ms. A process runs until it blocks, terminates, or uses up its time slice.

Scheduling Algorithms
Round Robin (RR)
Example: Assuming a time quantum of 4 ms, whats the average waiting time?

Issue: Whats the right value for the time quantum?

Too long => poor response time Too short => poor throughput

Scheduling Algorithms
Round Robin (RR) RR pros & cons:
+Works well for short jobs; typically used in timesharing systems. High overhead due to frequent context switches. Increases average waiting time, especially if CPU bursts are the same length and need more than one time quantum.

Scheduling Algorithms
Priority Scheduling
Select the process with the highest priority. Priority based on some attribute of the process (e.g., memory requirements, owner of process, etc.)

Issue:
Starvation: low priority jobs may wait indefinitely. Can prevent starvation by aging (increase process priority as a function of the waiting time).

Scheduling Algorithms
Shortest Job First (SJF)
Special case of priority scheduling (priority = expected length of CPU burst) Non-preemptive version: scheduler chooses the process with the least amount of work to do (shortest CPU burst). Preemptive version: scheduler chooses the process with the shortest remaining time to completion -- a running process can be interrupted.

Scheduling Algorithms
Shortest Job First (SJF)
Example: Whats the average waiting time?

Issue: How do you predict the future?

In practice systems use past process behavior to predict the length of the next CPU burst.

Scheduling Algorithms
Shortest Job First (SJF) SJF pros & cons:
+Better average response time. + Its the best you can do to minimize average response time-- can prove the algorithm is optimal. Difficult to predict the future. Unfair-- possible starvation (many short jobs can keep long jobs from making any progress).

Scheduling Algorithms
Multi-level Queues
Maintain multiple ready queues based on process type (e.g., interactive queue, CPU bound queue, etc.). Each queue has a priority; a process is permanently assigned to a queue. May use a different scheduling algorithm in each queue. Need to decide how to schedule between queues.

Scheduling Algorithms
Multi-level Feedback Queues
Adaptive algorithm: Processes can move between queues based on past behavior. Round robin scheduling in each queue -time slice increases in lower priority levels. Queue assignment:
Put new process in highest priority queue. If CPU burst takes longer than one time quantum, drop one level. If CPU burst completes before timer expires, move up one level.