Round Robbin (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).
  • The next job in the ready list (normally a queue) is selected to run
• 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?
  • Tradeoff
  • Small q makes system more responsive
  • Large q makes system more efficient since less switching

Homework: 9, 19, 20, 21

Processor Sharing (PS, **, PS, PS)

Merge the ready and running states and permit all ready jobs to be run at once. However, the processor slows down so that when n jobs are running at once each progresses at a speed 1/n as fast if it were running alone.

• Clearly impossible as stated due to overhead of process switching.
• Of theoretical interest (easy to analyze)
• Approximated by RR when the quantum is small. Make sure you understand this last point.

Homework: 18.

Variants of Round Robbin

• State dependent RR
  • Same as RR but q is varied dynamically depending on the state of the system
  • Favor processes holding important resources
    • For example, non-swappable memory
    • Perhaps medium term scheduling
• External priorities: RR but can pay more for bigger q

Priority Scheduling

Each job is assigned a priority (externally, perhaps by charging more for higher priority) and the highest priority ready job is run.

• Similar to ``External priorities'' above
• If many processes with the highest priority, use RR among them.
• Can easily starve processes (see aging below for fix).
• Can have the priorities changed dynamically to favor processes holding important resources (similar to state dependent RR).
• Many policies can be thought of as priority scheduling in which we run the job with the highest priority (with different notions of priority for different policies).

Priority aging

As a job is waiting, raise its priority so eventually it will have the maximum priority. Can apply this to many policies, in particular to priority scheduling described above

Homework: 22, 23

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

• Preemptive.
• Perhaps it could be called ``snobbish RR''.
• ``Accepted processes'' run RR.
• A new process waits until its priority reaches that of accepted processes (or until there are no accepted processes). At that point the new process is accepted.
• A new process starts at priority 0; its priority increases at rate a>=0.
• Accepted process have their priority increase at rate b>=0.
• 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

Shortest Job First (SPN, SJF, SJF, SJF)

Sort jobs by total execution time needed and run the shortest first.

• Nonpreemptive
• First consider a static situation where all jobs are available in the beginning, we know how long each one takes to run, and we implement ``run-to-completion'' (i.e., we don't even switch to another process on I/O). In this situation, then SJF has the shortest average waiting time
  • Moving a short job before a long one decreases the wait for the short by the length of the long and increases the wait of the long by the length of the short.
  • This decreases the total waiting time for these two.
  • Hence decreases the total waiting for all and hence decreases the average waiting time as well.
• In the more realistic case where the scheduler switches to a new process when the currently running process blocks (say for I/O), we should call the policy shortest next-CPU-burst first.
• The difficulty is predicting the future (i.e., knowing in advance the time required for the job or next-CPU-burst).

Preemptive Shortest Job First (PSPN, SRT, PSJF/SRTF, --)

Preemptive version of above

• Permit a process that enters the ready list to preempt the running process if the time for the new process (or for its first burst) is less than the remaining time for the running process (or for its current burst).
• It will never happen that an existing process in the ready list will require less time than the remaining time for the currently running process.
  • Why?
• Can starve processs that have a long burst.
  • This is fixed by the standard technique.
  • What is that technique?

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