For now we are discussing short-term scheduling, i.e., the arcs
connecting running ready.

Medium term scheduling is discussed later.

Preemption

It is important to distinguish preemptive from non-preemptive
scheduling algorithms.

Preemption means the operating system moves a process from running
to ready without the process requesting it.

Without preemption, the system implements ``run to completion (or
yield or block)''.

The ``preempt'' arc in the diagram.

We do not consider yield (a solid arrow from running to ready).

Preemption needs a clock interrupt (or equivalent).

Preemption is needed to guarantee fairness.

Found in all modern general purpose operating systems.

Even non preemptive systems can be multiprogrammed (e.g., when processes
block for I/O).

Deadline scheduling

This is used for real time systems. The objective of the scheduler is
to find a schedule for all the tasks (there are a fixed set of tasks)
so that each meets its deadline. The run time of each task is known
in advance.

Actually it is more complicated.

Periodic tasks

What if we can't schedule all task so that each meets its deadline
(i.e., what should be the penalty function)?

What if the run-time is not constant but has a known probability
distribution?

We do not cover deadline scheduling in this course.

The name game

There is an amazing inconsistency in naming the different
(short-term) scheduling algorithms. Over the years I have used
primarily 4 books: In chronological order they are Finkel, Deitel,
Silberschatz, and Tanenbaum. The table just below illustrates the
name game for these four books. After the table we discuss each
scheduling policy in turn.

Remark: For an alternate organization of the
scheduling algorithms (due to Eric Freudenthal and presented by him
Fall 2002) click here.

First Come First Served (FCFS, FIFO, FCFS, --)

If the OS ``doesn't'' schedule, it still needs to store the list of
ready processes in some manner. If it is a queue you get FCFS. If it
is a stack (strange), you get LCFS. Perhaps you could get some sort
of random policy as well.

Only FCFS is considered.

Non-preemptive.

The simplist scheduling policy.

The most efficient usage of cpu since the scheduler is very fast.

Round Robin (RR, RR, RR, RR)

An important preemptive policy.

Essentially the preemptive version of FCFS.

The key parameter is the quantum size q.

When a process is put into the running state a timer is set to q.

If the timer goes off and the process is still running, the OS
preempts the process.

This process is moved to the ready state (the
preempt arc in the diagram), where it is placed at the
rear of the ready list (a queue).

The process at the front of the ready list is removed from
the ready list and run (i.e., moves to state running).

When a process is created, it is placed at the rear of the ready list.

As q gets large, RR approaches FCFS

As q gets small, RR approaches PS (Processor Sharing, described next)

What value of q should we choose?

Trade-off

Small q makes system more responsive.

Large q makes system more efficient since less process switching.

Homework: 26, 35, 38.

Homework: Give an argument favoring a large
quantum; give an argument favoring a small quantum.

Process

CPU Time

Creation Time

P1

20

0

P2

3

3

P3

2

5

Homework:
(Remind me to discuss this last one in class next time):
Consider the set of processes in the table below.
When does each process finish if RR scheduling is used with q=1, if
q=2, if q=3, if q=100. First assume (unrealistically) that context
switch time is zero. Then assume it is .1.
Each process performs no
I/O (i.e., no process ever blocks). All times are in milliseconds.
The CPU time is the total time required for the process (excluding any
context switch time). The creation
time is the time when the process is created. So P1 is created when
the problem begins and P3 is created 5 milliseconds later.
If two processes have equal priority (in RR this means if thy both
enter the ready state at the same cycle), we give priority (in RR this
means place first on the queue) to the process with the earliest
creation time.
If they also have the same creation time, then we give priority to the
process with the lower number.