Shortest Job First CPU Scheduling with Predicted Burst Time

Shortest Job First (SJF) is an optimal scheduling algorithm as it gives maximum Throughput and minimum average waiting time (WT) and turnaround time (TAT) but it is not practically implementable because the burst time of a process can't be predicted in advance.

We may not know the length of the next CPU burst but we may be able to predict its value. We expect the next CPU burst will be similar in length to the previous ones. By computing an approximation of the length of the next CPU burst, we can pick the process with the shortest predicted CPU burst.

SJF is a CPU scheduling algorithm that selects the process with the smallest next CPU burst time. Since actual burst times are not known in advance, we predict them using past behavior.

Methods to Predict Burst Time

There are two methods by which we can predict the burst time of the process:

Static Method

We can predict the burst time by two factors using the static method:

Process size: Let's say we have Process P_old having size 200 KB which is already executed and its Burst-time is 20 Units of time, now let us say we have a New Process P_new having size 201 KB which is yet to be executed.

We take the Burst Time of the already executed process P_old which is almost of the same size as that of the New process as the Burst Time of the New Process P_new.

Process type: We can predict burst time depending on the Type of Process.

Operating System processes (like scheduler, dispatcher, segmentation, and fragmentation) are faster than User processes (Gaming, application software). Burst Time for any New OS process can be predicted from any old OS process of similar type and the same for the User process.

• OS Processes : These include system-level processes such as:
  • Schedulers
  • Compilers
  • Program managers
    Burst Time: Typically short, around 3 to 5 units, since these processes are small, frequent, and fast.

• User Processes : User processes are initiated by users and are categorized based on interaction and resource usage:
  • Interactive Processes : Short CPU bursts due to frequent waiting for user actions.
  • Foreground Processes: Moderate burst time balanced between CPU and I/O operations.
  • Background Processes: Longer, since they often perform heavy or ongoing computations.

Dynamic Technique

Simple average: Given n processes ( P₁, P₂... P_n)

Τ_n+1 = (Σ^{i=1 to n} t_i).1/n

Exponential average (Aging):

Τ_n+1 = αt_n + (1 - α)Τ_n

• where α = is smoothing factor and 0 <= α <= 1 , t_n = actual burst time of n^th process, Τ_n = predicted burst time of n^th process. General term,

αt_n + (1 - α)αt_n-1 + (1 - α)²αt_n-2...+ (1 - α)^jαt_n-j...+ (1 - α)ⁿ⁺¹Τ₀

• Τ₀ is a constant or overall system average.
• If α = 0, Τ_n+1 = Τ_n i.e. no change in value of initial predicted burst time.
• If α = 1, Τ_n+1 = t_n i.e. predicted Burst Time of new process will always change according to the actual Burst-time of n^th process.
• If α = 1/2, recent and past history are equally weighted.

How SJF with Prediction Works

• Initialize: Each process starts with an initial predicted burst time Τ₀ .
• Monitor Actual Burst: After each execution, record actual burst t_n .
• Update Prediction: Use exponential averaging to calculate Τ_n+1 .
• Schedule: Select the process with the smallest T .

Example :

SJF chooses P2 since ​Τ_n+1 = 2.5 < 5.5 (P1).

Additional Considerations for SJF Scheduling Algorithm

• The SJF algorithm is useful in scenarios where the processes have varying burst times and there is a need to minimize the average waiting time of processes in the ready queue.

• One of the major drawbacks of the SJF algorithm is that it can lead to starvation for processes with longer burst times, as they may never get a chance to execute if shorter processes keep arriving.

• Preemptive SJF can address the issue of starvation by allowing processes with shorter burst times to be interrupted by processes with even shorter burst times.

• Predicting the burst time accurately can be challenging, especially for processes that have burst times that vary significantly over time.

Advantages

• Minimizes average waiting time.
• Efficient for batch systems where CPU bursts are predictable.

Disadvantages

• Starvation: Long jobs may wait indefinitely.
• Requires accurate burst time prediction.
• Hard to implement in real-time systems.