# Program for Priority CPU Scheduling | Set 1

Priority scheduling is one of the most common scheduling algorithms in batch systems. Each process is assigned a priority. The process with the highest priority is to be executed first and so on. Processes with the same priority are executed on a first-come first served basis. Priority can be decided based on memory requirements, time requirements or any other resource requirement. Also priority can be decided on the ratio of average I/O to average CPU burst time.

Implementation:

```1- First input the processes with their burst time
and priority.
2- Sort the processes, burst time and priority
according to the priority.
3- Now simply apply FCFS algorithm.```

Note: A major problem with priority scheduling is indefinite blocking or starvation. A solution to the problem of indefinite blockage of the low-priority process is aging. Aging is a technique of gradually increasing the priority of processes that wait in the system for a long period of time.

## C++

 `// C++ program for implementation of FCFS ``// scheduling ``#include ``using` `namespace` `std; `` ` `struct` `Process { ``    ``int` `pid; ``// Process ID ``    ``int` `bt; ``// CPU Burst time required ``    ``int` `priority; ``// Priority of this process ``}; `` ` `// Function to sort the Process acc. to priority ``bool` `comparison(Process a, Process b) ``{ ``    ``return` `(a.priority > b.priority); ``} `` ` `// Function to find the waiting time for all ``// processes ``void` `findWaitingTime(Process proc[], ``int` `n, ``int` `wt[]) ``{ ``    ``// waiting time for first process is 0 ``    ``wt[0] = 0; `` ` `    ``// calculating waiting time ``    ``for` `(``int` `i = 1; i < n; i++) ``        ``wt[i] = proc[i - 1].bt + wt[i - 1]; ``} `` ` `// Function to calculate turn around time ``void` `findTurnAroundTime(Process proc[], ``int` `n, ``int` `wt[], ``                        ``int` `tat[]) ``{ ``    ``// calculating turnaround time by adding ``    ``// bt[i] + wt[i] ``    ``for` `(``int` `i = 0; i < n; i++) ``        ``tat[i] = proc[i].bt + wt[i]; ``} `` ` `// Function to calculate average time ``void` `findavgTime(Process proc[], ``int` `n) ``{ ``    ``int` `wt[n], tat[n], total_wt = 0, total_tat = 0; `` ` `    ``// Function to find waiting time of all processes ``    ``findWaitingTime(proc, n, wt); `` ` `    ``// Function to find turn around time for all processes ``    ``findTurnAroundTime(proc, n, wt, tat); `` ` `    ``// Display processes along with all details ``    ``cout << ``"\nProcesses  "``         ``<< ``" Burst time  "``         ``<< ``" Waiting time  "``         ``<< ``" Turn around time\n"``; `` ` `    ``// Calculate total waiting time and total turn ``    ``// around time ``    ``for` `(``int` `i = 0; i < n; i++) { ``        ``total_wt = total_wt + wt[i]; ``        ``total_tat = total_tat + tat[i]; ``        ``cout << ``"   "` `<< proc[i].pid << ``"\t\t"` `<< proc[i].bt ``             ``<< ``"\t    "` `<< wt[i] << ``"\t\t  "` `<< tat[i] ``             ``<< endl; ``    ``} `` ` `    ``cout << ``"\nAverage waiting time = "``         ``<< (``float``)total_wt / (``float``)n; ``    ``cout << ``"\nAverage turn around time = "``         ``<< (``float``)total_tat / (``float``)n; ``} `` ` `void` `priorityScheduling(Process proc[], ``int` `n) ``{ ``    ``// Sort processes by priority ``    ``sort(proc, proc + n, comparison); `` ` `    ``cout << ``"Order in which processes gets executed \n"``; ``    ``for` `(``int` `i = 0; i < n; i++) ``        ``cout << proc[i].pid << ``" "``; `` ` `    ``findavgTime(proc, n); ``} `` ` `// Driver code ``int` `main() ``{ ``    ``Process proc[] ``        ``= { { 1, 10, 2 }, { 2, 5, 0 }, { 3, 8, 1 } }; ``    ``int` `n = ``sizeof` `proc / ``sizeof` `proc[0]; ``    ``priorityScheduling(proc, n); ``    ``return` `0; ``}`

## Java

 `// Java program for implementation of FCFS ``// scheduling ``import` `java.util.*; `` ` `class` `Process { ``    ``int` `pid; ``// Process ID ``    ``int` `bt; ``// CPU Burst time required ``    ``int` `priority; ``// Priority of this process ``    ``Process(``int` `pid, ``int` `bt, ``int` `priority) ``    ``{ ``        ``this``.pid = pid; ``        ``this``.bt = bt; ``        ``this``.priority = priority; ``    ``} ``    ``public` `int` `prior() { ``return` `priority; } ``} `` ` `public` `class` `GFG { `` ` `    ``// Function to find the waiting time for all ``    ``// processes ``    ``public` `void` `findWaitingTime(Process proc[], ``int` `n, ``                                ``int` `wt[]) ``    ``{ `` ` `        ``// waiting time for first process is 0 ``        ``wt[``0``] = ``0``; `` ` `        ``// calculating waiting time ``        ``for` `(``int` `i = ``1``; i < n; i++) ``            ``wt[i] = proc[i - ``1``].bt + wt[i - ``1``]; ``    ``} `` ` `    ``// Function to calculate turn around time ``    ``public` `void` `findTurnAroundTime(Process proc[], ``int` `n, ``                                   ``int` `wt[], ``int` `tat[]) ``    ``{ ``        ``// calculating turnaround time by adding ``        ``// bt[i] + wt[i] ``        ``for` `(``int` `i = ``0``; i < n; i++) ``            ``tat[i] = proc[i].bt + wt[i]; ``    ``} `` ` `    ``// Function to calculate average time ``    ``public` `void` `findavgTime(Process proc[], ``int` `n) ``    ``{ ``        ``int` `wt[] = ``new` `int``[n], tat[] = ``new` `int``[n], ``            ``total_wt = ``0``, total_tat = ``0``; `` ` `        ``// Function to find waiting time of all processes ``        ``findWaitingTime(proc, n, wt); `` ` `        ``// Function to find turn around time for all ``        ``// processes ``        ``findTurnAroundTime(proc, n, wt, tat); `` ` `        ``// Display processes along with all details ``        ``System.out.print( ``            ``"\nProcesses   Burst time   Waiting time   Turn around time\n"``); `` ` `        ``// Calculate total waiting time and total turn ``        ``// around time ``        ``for` `(``int` `i = ``0``; i < n; i++) { ``            ``total_wt = total_wt + wt[i]; ``            ``total_tat = total_tat + tat[i]; ``            ``System.out.print(``" "` `+ proc[i].pid + ``"\t\t"``                             ``+ proc[i].bt + ``"\t "` `+ wt[i] ``                             ``+ ``"\t\t "` `+ tat[i] + ``"\n"``); ``        ``} `` ` `        ``System.out.print(``"\nAverage waiting time = "``                         ``+ (``float``)total_wt / (``float``)n); ``        ``System.out.print(``"\nAverage turn around time = "``                         ``+ (``float``)total_tat / (``float``)n); ``    ``} `` ` `    ``public` `void` `priorityScheduling(Process proc[], ``int` `n) ``    ``{ `` ` `        ``// Sort processes by priority ``        ``Arrays.sort(proc, ``new` `Comparator() { ``            ``@Override``            ``public` `int` `compare(Process a, Process b) ``            ``{ ``                ``return` `b.prior() - a.prior(); ``            ``} ``        ``}); ``        ``System.out.print( ``            ``"Order in which processes gets executed \n"``); ``        ``for` `(``int` `i = ``0``; i < n; i++) ``            ``System.out.print(proc[i].pid + ``" "``); `` ` `        ``findavgTime(proc, n); ``    ``} `` ` `    ``// Driver code ``    ``public` `static` `void` `main(String[] args) ``    ``{ ``        ``GFG ob = ``new` `GFG(); ``        ``int` `n = ``3``; ``        ``Process proc[] = ``new` `Process[n]; ``        ``proc[``0``] = ``new` `Process(``1``, ``10``, ``2``); ``        ``proc[``1``] = ``new` `Process(``2``, ``5``, ``0``); ``        ``proc[``2``] = ``new` `Process(``3``, ``8``, ``1``); ``        ``ob.priorityScheduling(proc, n); ``    ``} ``} `` ` `// This code is contributed by rahulpatil07109.`

## Python3

 `# Python3 program for implementation of ``# Priority Scheduling `` ` `# Function to find the waiting time ``# for all processes `` ` ` ` `def` `findWaitingTime(processes, n, wt): ``    ``wt[``0``] ``=` `0`` ` `    ``# calculating waiting time ``    ``for` `i ``in` `range``(``1``, n): ``        ``wt[i] ``=` `processes[i ``-` `1``][``1``] ``+` `wt[i ``-` `1``] `` ` `# Function to calculate turn around time `` ` ` ` `def` `findTurnAroundTime(processes, n, wt, tat): `` ` `    ``# Calculating turnaround time by ``    ``# adding bt[i] + wt[i] ``    ``for` `i ``in` `range``(n): ``        ``tat[i] ``=` `processes[i][``1``] ``+` `wt[i] `` ` `# Function to calculate average waiting ``# and turn-around times. `` ` ` ` `def` `findavgTime(processes, n): ``    ``wt ``=` `[``0``] ``*` `n ``    ``tat ``=` `[``0``] ``*` `n `` ` `    ``# Function to find waiting time ``    ``# of all processes ``    ``findWaitingTime(processes, n, wt) `` ` `    ``# Function to find turn around time ``    ``# for all processes ``    ``findTurnAroundTime(processes, n, wt, tat) `` ` `    ``# Display processes along with all details ``    ``print``(``"\nProcesses    Burst Time    Waiting"``, ``          ``"Time    Turn-Around Time"``) ``    ``total_wt ``=` `0``    ``total_tat ``=` `0``    ``for` `i ``in` `range``(n): `` ` `        ``total_wt ``=` `total_wt ``+` `wt[i] ``        ``total_tat ``=` `total_tat ``+` `tat[i] ``        ``print``(``" "``, processes[i][``0``], ``"\t\t"``, ``              ``processes[i][``1``], ``"\t\t"``, ``              ``wt[i], ``"\t\t"``, tat[i]) `` ` `    ``print``(``"\nAverage waiting time = %.5f "` `%` `(total_wt ``/` `n)) ``    ``print``(``"Average turn around time = "``, total_tat ``/` `n) `` ` ` ` `def` `priorityScheduling(proc, n): `` ` `    ``# Sort processes by priority ``    ``proc ``=` `sorted``(proc, key``=``lambda` `proc: proc[``2``], ``                  ``reverse``=``True``) `` ` `    ``print``(``"Order in which processes gets executed"``) ``    ``for` `i ``in` `proc: ``        ``print``(i[``0``], end``=``" "``) ``    ``findavgTime(proc, n) `` ` ` ` `# Driver code ``if` `__name__ ``=``=` `"__main__"``: `` ` `    ``# Process id's ``    ``proc ``=` `[[``1``, ``10``, ``1``], ``            ``[``2``, ``5``, ``0``], ``            ``[``3``, ``8``, ``1``]] ``    ``n ``=` `3``    ``priorityScheduling(proc, n) `` ` `# This code is contributed ``# Shubham Singh(SHUBHAMSINGH10) `

## Javascript

 `// JavaScript program for implementation of Priority Scheduling ``class Process { ``    ``constructor(pid, bt, priority) { ``        ``this``.pid = pid; ``// Process ID ``        ``this``.bt = bt; ``// CPU Burst time required ``        ``this``.priority = priority; ``// Priority of this process ``    ``} `` ` `    ``prior() { ``        ``return` `this``.priority; ``    ``} ``} `` ` `class GFG { ``    ``// Function to find the waiting time for all processes ``    ``findWaitingTime(proc, n, wt) { ``        ``// waiting time for first process is 0 ``        ``wt[0] = 0; ``        ``// calculating waiting time ``        ``for` `(let i = 1; i < n; i++) { ``            ``wt[i] = proc[i - 1].bt + wt[i - 1]; ``        ``} ``    ``} `` ` `    ``// Function to calculate turn around time ``    ``findTurnAroundTime(proc, n, wt, tat) { ``        ``// calculating turnaround time by adding bt[i] + wt[i] ``        ``for` `(let i = 0; i < n; i++) { ``            ``tat[i] = proc[i].bt + wt[i]; ``        ``} ``    ``} `` ` `    ``// Function to calculate average time ``    ``findavgTime(proc, n) { ``        ``let wt = ``new` `Array(n); ``        ``let tat = ``new` `Array(n); ``        ``let total_wt = 0; ``        ``let total_tat = 0; ``        ``// Function to find waiting time of all processes ``        ``this``.findWaitingTime(proc, n, wt); `` ` `        ``// Function to find turn around time for all processes ``        ``this``.findTurnAroundTime(proc, n, wt, tat); `` ` `        ``// Display processes along with all details ``        ``console.log(``"Processes   Burst time   Waiting time   Turn around time"``); `` ` `        ``// Calculate total waiting time and total turn around time ``        ``for` `(let i = 0; i < n; i++) { ``            ``total_wt = total_wt + wt[i]; ``            ``total_tat = total_tat + tat[i]; ``            ``console.log( ``                ``" "` `+ proc[i].pid + ``"\t\t"` `+ proc[i].bt + ``"\t "` `+ wt[i] + ``"\t\t "` `+ tat[i] ``            ``); ``        ``} `` ` `        ``console.log( ``            ``"Average waiting time = "` `+ total_wt / n ``        ``); ``        ``console.log( ``            ``"Average turn around time = "` `+ total_tat / n ``        ``); ``    ``} `` ` `    ``priorityScheduling(proc, n) { ``        ``// Sort processes by priority ``        ``proc.sort((a, b) => b.prior() - a.prior()); ``        ``console.log(``"Order in which processes get executed:"``); ``        ``for` `(let i = 0; i < n; i++) { ``            ``console.log(proc[i].pid + ``" "``); ``        ``} `` ` `        ``this``.findavgTime(proc, n); ``    ``} ``} `` ` `// Driver code ``let ob = ``new` `GFG(); ``let n = 3; ``let proc = []; ``proc[0] = ``new` `Process(1, 10, 2); ``proc[1] = ``new` `Process(2, 5, 0); ``proc[2] = ``new` `Process(3, 8, 1); ``ob.priorityScheduling(proc, n); ``//This code is Contributed by chinmaya121221`

## C#

 `using` `System; ``using` `System.Collections.Generic; `` ` ` ``class` `Process ``{ ``public` `int` `pid; ``// Process ID ``    ``public` `int` `bt; ``// CPU Burst time required ``    ``public` `int` `priority; ``// Priority of this process ``public` `Process(``int` `pid, ``int` `bt, ``int` `priority) ``{ ``    ``this``.pid = pid; ``    ``this``.bt = bt; ``    ``this``.priority = priority; ``} `` ` `public` `int` `Prior ``{ ``    ``get` `{ ``return` `priority; } ``} ``} `` ` `class` `GFG ``{ ``// Function to find the waiting time for all processes ``public` `void` `findWaitingTime(Process[] proc, ``int` `n, ``int``[] wt) ``{ ``// waiting time for first process is 0 ``wt[0] = 0;   ``     ``// calculating waiting time ``    ``for` `(``int` `i = 1; i < n; i++) ``        ``wt[i] = proc[i - 1].bt + wt[i - 1]; ``} `` ` `// Function to calculate turn around time ``public` `void` `findTurnAroundTime(Process[] proc, ``int` `n, ``int``[] wt, ``int``[] tat) ``{ ``    ``// calculating turnaround time by adding ``    ``// bt[i] + wt[i] ``    ``for` `(``int` `i = 0; i < n; i++) ``        ``tat[i] = proc[i].bt + wt[i]; ``} `` ` `// Function to calculate average time ``public` `void` `findavgTime(Process[] proc, ``int` `n) ``{ ``    ``int``[] wt = ``new` `int``[n]; ``    ``int``[] tat = ``new` `int``[n]; ``    ``int` `total_wt = 0; ``    ``int` `total_tat = 0; `` ` `    ``// Function to find waiting time of all processes ``    ``findWaitingTime(proc, n, wt); `` ` `    ``// Function to find turn around time for all processes ``    ``findTurnAroundTime(proc, n, wt, tat); `` ` `    ``// Display processes along with all details ``    ``Console.WriteLine(``"\nProcesses   Burst time   Waiting time   Turn around time"``); `` ` `    ``// Calculate total waiting time and total turn around time ``    ``for` `(``int` `i = 0; i < n; i++) ``    ``{ ``        ``total_wt = total_wt + wt[i]; ``        ``total_tat = total_tat + tat[i]; ``        ``Console.WriteLine(``" "` `+ proc[i].pid + ``"\t\t"` `+ proc[i].bt + ``"\t "` `+ wt[i] + ``"\t\t "` `+ tat[i]); ``    ``} `` ` `    ``Console.WriteLine(``"\nAverage waiting time = "` `+ (``float``)total_wt / (``float``)n); ``    ``Console.WriteLine(``"Average turn around time = "` `+ (``float``)total_tat / (``float``)n); ``} `` ` `public` `void` `priorityScheduling(Process[] proc, ``int` `n) ``{ ``    ``// Sort processes by priority ``    ``Array.Sort(proc, ``new` `Comparison((a, b) => b.Prior.CompareTo(a.Prior))); ``    ``Console.WriteLine(``"Order in which processes gets executed "``); `` ` `    ``for` `(``int` `i = 0; i < n; i++) ``        ``Console.Write(proc[i].pid + ``" "``); `` ` `    ``findavgTime(proc, n); ``} `` ` `// Driver code ``static` `void` `Main(``string``[] args) ``{ ``    ``GFG ob = ``new` `GFG(); ``    ``int` `n = 3; ``    ``Process[] proc = ``new` `Process[n]; ``    ``proc[0] = ``new` `Process(1, 10, 2); ``    ``proc[1] = ``new` `Process(2, 5, 0); ``    ``proc[2] = ``new` `Process(3, 8, 1); ``    ``ob.priorityScheduling(proc, n); ``} ``}  `

Output:

```Order in which processes gets executed
1 3 2
Processes  Burst time  Waiting time  Turn around time
1        10     0         10
3        8     10         18
2        5     18         23

Average waiting time = 9.33333
Average turn around time = 17```

• Priority-based scheduling ensures that high-priority processes are executed first, which can lead to faster completion of critical tasks.
• Priority scheduling is useful for real-time systems that require processes to meet strict timing constraints.
• Priority scheduling can reduce the average waiting time for processes that require a significant amount of CPU time.

• Priority inversion: Priority inversion occurs when a low-priority process holds a resource that a high-priority process requires. This can cause delays in the execution of high-priority processes.
• Starvation: If the system is heavily loaded with high-priority processes, low-priority processes may never get a chance to execute.
• Priority inversion avoidance techniques, such as priority inheritance or priority ceiling protocols, can introduce additional complexity to the system.
• Setting priorities can be a difficult task, especially when there are many processes with different priorities.

In this post, the processes with arrival time 0 are discussed. In the next set, we will be considering different arrival times to evaluate waiting times.

Previous
Next