NOTE: These notes are adapted from those of Allan Gottlieb, and are reproduced here with his permission.

================ Start Lecture #5 (Feb. 5)

## Scheduling (Continued)

### Selfish RR (SRR, **, SRR, **)

• Preemptive.
• Perhaps it should be called ``snobbish RR''.
• ``Accepted processes'' run RR.
• Accepted process have their priority increase at rate b>=0.
• A new process starts at priority 0; its priority increases at rate a>=0.
• A new process becomes an accepted process when its priority reaches that of an accepted process (or until there are no accepted processes).
• Note that at any time all accepted processes have same priority.
• If b>=a, get FCFS.
• If b=0, get RR.
• If a>b>0, it is interesting.

### Highest Penalty Ratio Next (HPRN, HRN, **, **)

Run the process that has been ``hurt'' the most.
• For each process, let r = T/t; where T is the wall clock time this process has been in system and t is the running time of the process to date.
• If r=5, that means the job has been running 1/5 of the time it has been in the system.
• We call r the penalty ratio and run the process having the highest r value.
• HPRN is normally defined to be non-preemptive (i.e., the system only checks r when a burst ends), but there is an preemptive analogue
• Do not worry about a process that just enters the system (its ratio is undefined)
• When putting process into the run state commpute the time at which it will no longer have the highest ratio and set a timer.
• When a process is moved into the ready state, compute its ratio and preempt if needed.
• HRN stands for highest response ratio next and means the same thing.
• This policy is another example of priority scheduling

### Multilevel Queues (**, **, MLQ, **)

Put different classes of processs in different queues

• Processs do not move from one queue to another.
• Can have different policies on the different queues.
For example, might have a background (batch) queue that is FCFS and one or more foreground queues that are RR.
• Must also have a policy among the queues.
For example, might have two queues, foreground and background, and give the first absolute priority over the second
• Might apply aging to prevent background starvation.
• But might not, i.e., no guarantee of service for background processes. View a background process as a ``cycle soaker''.
• Might have 3 queues, foreground, background, cycle soaker

### Multilevel Feedback Queues (FB, MFQ, MLFBQ, MQ)

Many queues and processs move from queue to queue in an attempt to dynamically separate ``batch-like'' from interactive processs.

• Run processs from the highest priority nonempty queue in a RR manner.
• When a process uses its full quanta (looks a like batch process), move it to a lower priority queue.
• When a process doesn't use a full quanta (looks like an interactive process), move it to a higher priority queue.
• A long process with frequent (perhaps spurious) I/O will remain in the upper queues.
• Might have the bottom queue FCFS.
• Many variants
For example, might let process stay in top queue 1 quantum, next queue 2 quanta, next queue 4 quanta (i.e. return a process to the rear of the same queue it was in if the quantum expires).

### Theoretical Issues

Considerable theory has been developed.

• NP completeness results abound.
• Much work in queuing theory to predict performance.
• Not covered in this course.

### Medium-Term Scheduling

In addition to the short-term scheduling we have discussed, we add medium-term scheduling in which decisions are made at a coarser time scale.

• Called memory scheduling by Tanenbaum (part of three level scheduling).
• Suspend (swap out) some process if memory is over-committed.
• Criteria for choosing a victim.
• How long since previously suspended.
• How much CPU time used recently.
• How much memory does it use.
• External priority (pay more, get swapped out less).
• We will discuss medium term scheduling again next chapter (memory management).

### Long Term Scheduling

• ``Job scheduling''. Decide when to start jobs, i.e., do not necessarily start them when submitted.
• Force user to log out and/or block logins if over-committed.
• CTSS (an early time sharing system at MIT) did this to insure decent interactive response time.
• Unix does this if out of processes (i.e., out of PTEs)
• ``LEM jobs during the day'' (Grumman).

• Called admission scheduling by Tanenbaum (part of three level scheduling).
• Some supercomputer sites.

## Creating a process

See Tanenbaum pp. 691-696 for Unix; pp. 799-800 for Window.

## 2.2: Interprocess Communication (IPC) and Process Coordination and Synchronization

### 2.2.1: Race Conditions

A race condition occurs when two processes can interact and the outcome depends on the order in which the processes execute.

• Imagine two processes both accessing x, which is initially 10.
• One process is to execute x <-- x+1
• The other is to execute x <-- x-1
• When both are finished x should be 10
• But we might get 9 and might get 11!
• Show how this can happen (x <-- x+1 is not atomic)
• Tanenbaum shows how this can lead to disaster for a printer spooler