CS 3733 Operating Systems

• 16-31 are for real-time queues. They are scheduled according to priorities on a preemptive basis.
• 0-15 are dynamic queues. All processes from a given queue are executed before processes from any lower number queue is considered.
• Each system call has a priority increment. When an event occurs which causes a process to become executable, its priority is computed as the sum of the base and the increment.
• Each time a process is scheduled its priority is decremented, but not below the base.
• Processes also age if they spend a long time in a queue. This allows them to increase their priority.

• All runnable processes are assigned a number that determines which queue they are placed in.
• Lower numbers mean higher priority. Negative numbers are for system processes which cannot be killed by signals.
• The first process in lowest nonempty queue is run. (You can nice to reduce your priority.)
• A time quantum of 0.1 second is used.
• When a process attains a higher priority, the system switches to that process when the quantum of the running process is finished.
• When a sleeping process is awakened, the current process is preempted after any current system call.
• The process's user-mode priority is:

  p_usrpri = PUSER + p_cpu/4 + 2 p_nice

  Here p_cpu is incremented each time the system clock ticks and the process is found to be executing. It is also adjusted once per second using a digital decay filter.

  p_cpu = [(2 load)/(2 load + 1)]p_cpu + p_nice

  where load is the sampled average length of the run queue over the previous 1-minute interval of system operation.

• When a process is blocked for an event, it cannot accumulate CPU time. When a process has been sleeping for longer than 1 second,

  p_cpu = [ (2 load)/(2 load + 1)]^p_slptime p_cpu

  where p_slptime is an estimate of how long the process has been blocked and load is the current system load.

• The system does not preempt processes executing in kernal mode. This means it is not good for real-time system.

• Thread states:
  • Ready - waiting to run
  • Standby - next one to run (highest priority ready)
  • Running - thread that is executing
  • Waiting - blocked waiting for an event
  • Transition - new thread while it is being create.
  • Terminated - finishes execution

• Dispatcher
  • 32-level priority (real-time class 16 to 31; variable class is 0 to 15)
  • Traverses queues from highest to lowest
  • If no ready thread, runs the idle thread
  • If a thread's quantum expires, its priority is decreased, but never below base.
  • When released from wait state, gets a priority boost that depends on the type of wait.
  • Preempts for higher priority jobs.

Skill: Understand how real scheduling algorithms work.