Operating System - Priority Scheduling Algorithm

---

---

Priority scheduling is a CPU scheduling strategy that decides which process in the ready queue should execute next based on the priorities assigned to the process. It is commonly used in systems where the execution of the processes are made in batches.

Priority Scheduling

In systems where Priority Scheduling strategies are implemented, each process is assigned a priority value. Some systems follow the scheme that lower the priority value, higher the priority; while other systems follow the scheme of higher the priority value, higher the priority. The process with the highest priority value is selected for execution.

There are two variants of Priority scheduling −

Non-preemptive Priority Scheduling

In the non-preemptive version, once a process is assigned to the CPU, it runs into completion. Here, the scheduler is invoked when a process completes its execution or when a new process(es) arrives in an empty ready queue. The scheduler chooses the process with highest priority for execution.

Preemptive Priority Scheduling

In the preemptive version, if a high priority process enters the system while a lower priority process is executing, process switch occurs by which the executing process is swapped out while the newly arrived higher priority process starts to execute. Thus the scheduler is invoked either when a new process arrives in the system or an existing process completes its execution.

Priority values can be also categorized into two forms −

• Static Priority: In this system, once a priority value is assigned to a process, it remains constant as long as the process remains in the system.
• Dynamic Priority: Here, the priority values changes according to the nature of the process or the waiting time of the process in the system.

Features of Priority Scheduling

• The process with the highest priority is assigned to the CPU.
• Non-preemptive priority scheduling that uses static priorities, are typically used in batch processes.
• Preemptive priority scheduling that uses dynamic priority is used in most operating systems.
• If two processes are of same highest priority, then the scheduler arbitrates between them on first come first serve basis.
• Since most systems have some high priority system processes, priority scheduling finds its wide implementation, often in conjunction with other scheduling algorithms.

We can understand the workings Priority scheduling algorithm through the aid of the following examples −

Examples of Non-Preemptive Priority Scheduling

Example 1

Suppose that we have a set of four processes that have arrived at the same time in the order P1, P2, P3 and P4. The burst time in milliseconds and their priorities of the processes is given by the following table −

Considering that a lower priority value means higher priority, let us perform non-preemptive priority scheduling on it. We will draw the GANTT chart and find the average turnaround time and average waiting time.

GANTT Chart

Process P2 has the highest priority and so it executes first. Then we find that both P1 and P4 have equal priority value of 2. Since P1 arrived before, CPU is allocated to P1 and then to P4. Finally P3 executes. Thus the order of execution is P2, P1, P4, P3 and is given by the following

Let us compute the average turnaround time and average waiting time from the above chart.

Average Turnaround Time

= Sum of Turnaround Time of each Process/ Number of Processes

= ( TAT_P1 + TAT_P2 + TAT_P3 + TAT_P4) / 4

= ( 16 + 10 + 26 + 22) / 4 = 18.5 ms

Average Waiting Time

= Sum of Waiting Time of Each Process/ Number of processes

= ( WT_P1 + WT_P2 + WT_P3 + WT_P4) / 4

= ( 10 + 0 + 22 + 16) / 4 = 10.5 ms

Example 2

In this example, we consider a situation when the processes arrive at different times. Suppose we have set of four processes whose arrival times, CPU burst times and priorities are as follows −

Let us draw the GANTT chart and find the average turnaround time and average waiting time using non-preemptive priority scheduling, considering lower priority value as higher priority.

GANTT Chart

At time 0ms, only P1 is there and so it is assigned to CPU. P1 completes execution at 6ms and at that time P2 and P3 have arrived. P2 has higher priority and hence assigned to CPU. P2 completes execution at time 10ms. By that time P4 has arrived having priority value 1 and so it is assigned to CPU. Once P4 completes execution, P3 is assigned to CPU. So the order of execution is P1, P2, P4, P3 as shown in the following GANTT chart −

Let us calculate the turnaround time of each process and hence the average.

Turnaround Time of a process = Completion Time Arrival Time

TAT_P1 = CT_P1 - AT_P1 = 6 - 0 = 6ms

TAT_P2 = CT_P2 - AT_P2 = 16 - 4 = 12ms

TAT_P3 = CT_P3 - AT_P3 = 23 - 4 = 19ms

TAT_P4 = CT_P4 - AT_P4 = 19 - 8 = 11ms

Average Turnaround Time

= Sum of Turnaround Time of each Process / Number of Processes

= ( 6 + 12+ 19 + 11) / 4 = 12 ms

The waiting time is given by the time that each process waits in the ready queue. For a non-preemptive scheduling algorithm, waiting time of each process can be simply calculated as −

Waiting Time of any process = Time of admission to CPU Arrival Time

WT_P1 = 0 - 0 = 0ms

WT_P2 = 6 - 4 = 2ms

WT_P3 = 19 - 4 = 15ms

WT_P4 = 16 - 8 = 8ms

Average Waiting Time

= Sum of Waiting Time of Each Process / Number of processes

= (WT_P1 + WT_P2 + WT_P3 + WT_P4) / 4

= ( 0 + 2 +15 + 8) / 4 = 6.25 ms

Example of Preemptive Priority Scheduling

In preemptive priority scheduling, if a process arrives that has higher priority than the executing process, then the higher priority process pre-empts the lower priority process. Let us consider the following set of processes whose arrival times, burst times and priorities are give in the following table −

GANTT Chart

At time 0ms, P1 is the only process and so it starts executing. At time 4ms, P2 and P3 arrive. Since P2 has higher priority than P1, P2 preempts P1. At 10ms, P4 arrives which has higher priority than P2 and so pre-empts P2. P4 completes execution at 14ms and leaves. The processes in the system are P1, P2 and P3, among which P2 has highest priority and so is assigned to CPU. At 18ms, P2 completes execution and so P1 and P3 are the processes in the system. Since both processes are of same priority, the scheduler selects P1 by FCFS method. When P1 completes execution, finally P3 executes. The following GANTT chart shows the order of execution −

From the GANTT chart, we compute the average turnaround time and the average waiting time.

Average Turnaround Time

= Sum of Turnaround Time of each Process/ Number of Processes

= (TAT_P1 + TAT_P2 + TAT_P3 + TAT_P4) / 4

= ((22-0) + (18-4) + (25-4) + (14-10)) / 4 = 15.25 ms

Average Waiting Time

= Sum of Waiting Time of Each Process/ Number of processes

= (WT_P1 + WT_P2 + WT_P3 + WT_P4) / 4

= (14 + 4 + 18 +0) / 4 = 7 ms

Advantages of Priority Scheduling

• Implementation is simple since scheduler doesnt require doing any prior calculations.
• Once CPU defines the relative relevance (priorities) of the processes, the order of execution is easily predictable.
• Higher priority processes are almost served immediately.
• Priority scheduling is particularly helpful in systems that have variety of processes each with their own needs.

Disadvantages of Priority Scheduling

• In static priority systems, lower priority processes may need to wait indefinitely since the system is busy executing higher priority processes. This results in stagnation.
• Dynamic priority solves the stagnation problem. However, the added logic of dynamically updating priority values according to the system requires additional CPU cycles and thus increases load on the system.
• In non-preemptive priority scheduling, often a large process keeps shorter processes waiting for long time.
• In preemptive priority scheduling, a low priority process may be repeatedly pre-empted by intermittent streams of high priority processes requiring frequent context switches.

Conclusion

Priority scheduling algorithm paves way for more complex scheduling methods like multilevel queue scheduling. Assigning priorities to the processes helps the CPU to complete its important work first and leave the rest of the time for background processes. Priorities can be assigned to the processes as a function of their burst time, type of process, waiting time etc. and can thus incorporate the advantages of other basic scheduling algorithms.