Objectives

Notes

• This Simulation might be useful.
• First-come first-served
  • A process is placed in the queue when it arrives.
  • When a process terminates/ or has an I/O request it is removed from the queue and the process at the front of the queue is placed on the CPU.
  • This is nonpreemptive.
  • It is easy to implement and understand.
  • CPU utilization is maximized
  • Throughput is depends greatly on the CPU burst size of the processes.
  • Consider p1: 3 ms, p2: 5 ms, and p3: 20 ms
    • Assume all arrive nearly simultaneously but in a given order
      • p1, p2, p3: p1 waits 0, p2 waits 3 and p3 waits 7 for a total of 10 or an average of 3.33ms.
      • p3, p2, p1: p3 waits 0, p2 waits 20 and p1 waits 25 for a total of 45 or 15ms average.
  • Response time is similar.
  • And so is Turnaround time.
  • Variance in all three cases is large.
  • Consider what would happen as these repeatedly cycle through the CPU
    • The long CPU burst would eventually yield the CPU for i/o
    • All others would quickly cycle through
    • The the long CPU burst would be back on the CPU.
    • This would be made worse if the wait time for I/O is large enough that the I/O bound processes run and get thrown into the I/O queue.
      • Then the CPU would be idle.
    • In some sense, we relay on the CPU bound process to be "broken up" to take up the time the other processes are waiting for I/O.
• Shortest job first
  • Select the shortest job, let it complete, then the next, ...
  • This is actually the best solution to the problem presented before.
  • This can be proven to be optimal for non-preemptive scheduling.
  • The problem is, we can't know what the shortest job is.
    • They approximate it with a formula
    • $τ_{n+1} = αt_n + (1-α)τ_n$
      • τ is the estimate
      • t is the actual time.
      • α is a weight
        • 0 - the current time has no impact
        • 1 - the history has no impact
        • 1/2 equally weighted
  • This can be made to be preemptive
    • The queue is ordered by τ
    • If a new job arrives with shorter τ than the current process it is preempted.
    • This is not time-slice preemptive scheduling, but end time preemptive.
  • They give the following example:

    Process	Arrival Time	Burst Time
    P1	0	8
    P2	1	4
    P3	2	9
    P4	3	5

                                                                CPU      QUEUE
    At time 0, P1/8 arrives, 
          it is the only process so its run is started.         P1/8   
    At time 1, P2/4 arrives
          the burst time of P2 is shorter than P1 
             so P2 is run and P1 is placed in the queue         P2/4     P1/7
    At time 2, P3/9 arrives
           P3 is placed at the end of the queue                 P2/3     P1/7 P3/9
    At time 3, P4/5 arrives
           P4/5 moves to the front of the queue                 P2/2     P4/5 P1/7 P3/9 

• Round-Robin
  • FCFS with preemption
  • Preemption based on a time slice or quantum
    • After n ms, the process on the processor is interrupted and returned to the ready queue.
    • Or if the process has resource request before the quantum expires, the process will be removed from the CPU and placed in the I/O queue.
  • Given a quantum of 5 and the following

    Process	Arrival	Burst Time
    P1	0	12
    P2	1	7
    P3	2	15
    P4	3	6

    Trace the scheduling.
  • Tee trick is selecting the quantum
    • If it is too large, the result is FCFS
    • If it is too small, too much time is spent in the dispatcher
  • They state that in modern systems
    • The quantum is between 10 to 100 milliseconds
    • The time for a context switch is about 2-10 microseconds
    • cat /proc/sys/kernel/sched_rr_timeslice_ms, in ms
• Priority Scheduling
  • Each process has an associated priority
    • This can be user assigned - based on importance of task.
    • Or system assigned - based on resource utilization
  • The scheduler will select among those with the lowest/highest priority
  • Use a FCFS, or another method to break ties.
  • This can be preemptive (ie if a new job arrives with a lower priority it can preempt), or not.
  • They state that this can lead to starvation.
    • Processes with the worst priority (not likely to be selected) will not be selected to run.
    • Especially if new better priority processes are coming in.
    • In a busy system, the worst priority processes might not every get to run.
  • One solution is process aging
    • Gradually make the priority of processes better
• Round Robin With Priority and Quantum preemption.
  • Schedule round robin between each level of priority
  • Then move to the next level.
  • This can be implemented easily with a number of different queues.
    • One for each priority level.
    • Or even Real Time, System, Interactive, Batch, with a priority system in each queue.
  • In either case, this can lead to starvation
  • So some solution needs to be found.
    • The real time queue is serviced if it has entries.
    • Then
      • 60% of the time is spent on the system queue
      • 30% of the time is spent on the interactive queue
      • 10% of the time is spent on the batch queue.
• The last one they suggest is a mult-level feedback queue
  • Round robin with time preemption.
  • Multiple queues
    • Everything enters queue 0, this best priority.
    • If a process is swapped out too many times, it is reduced to a lower queue.
    • If a process is starving it is promoted to a higher queue.
  • All processes in a queue are run until the queue is empty
  • Then the system moves to the next level queue.
  • The queues may have different quantum values.
  • This system can be tuned on many different parameters
    • Number of queues and quantum for each queue
    • Promotion and demotion policies
    • Even apply different scheduling algorithms for each queue.
  • But it is the most complex algorithm to implement.