Round Robin Process Scheduling algorithm in operating systems

This tutorial covers the concepts of Round Robin Scheduling.

Round Robin Scheduling is the preemptive scheduling algorithm.

We assign a fixed time to all processes for execution, this time is called time quantum.

All processes can execute only until their time quantum and then leave the CPU and give a chance to other processes to complete their execution according to time quantum.

Context switching mechanisms store the states of preempted processes.

The formula of Round robin Turn Around Time = Completion Time – Arrival Time
The formula of Round robin Waiting Time(W.T): Time Difference between the turnaround and the burst time.
The formula of Round robin Waiting Time = Turn Around Time – Burst Time

Examples of Round-robin scheduling

Let’s see a round-robin scheduling example with arrival time, burst time, waiting time, and time quantum.

Time quantum = 2

Animation and Video of Round Robin Scheduling

Advantage of Round-robin Scheduling

There are many advantages of Round-robin Scheduling. Some of the advantages are mentioned below;

Round-robin Scheduling avoids starvation or convoy effect.
In Round-robin Scheduling , all the jobs get a fair and efficient allocation of CPU.
Round-robin Scheduling don’t care about priority of the processes.
Round-robin Scheduling gives the best performance in terms of average response time.
We can assume the worst case response time for the process, If we know the total number of processes on the running queue.
Round-robin Scheduling is easily implementable on the system because it does not depend upon burst time.
Round-robin Scheduling promotes Context switching to save the states of the preempted processes.

Disadvantages of Round-robin Scheduling

There are many disadvantages of Round-robin Scheduling. Some of the disadvantages are mentioned below;
Round-robin Scheduling utilize more time on context switching which is not good in some cases.
The processor output will be reduced in Round-robin Scheduling, If slicing time of OS is low.
If the time quantum is low, then it increases the context switching time in Round-robin Scheduling .
Round-robin Scheduling can leads to decreases the comprehension
In Round-robin Scheduling , it’s a difficult task to decide a correct time quantum to increase the efficiency and speed.
In Round-robin Scheduling , We can’t set priorities for the processes.
Performance of Round-robin Scheduling heavily depends on time quantum given to the processes.

Round robin scheduling program in C

#include<stdio.h> 
 
int main() 
{ 
 
  int T4Tutorials_counter,j,n,time,Remaining,flag=0,time_quantum; 
  int wait_time=0,turnaround_time=0,Arrival_Time[10],Burst_Time[10],rt[10]; 
  printf("Enter Total Process:\t "); 
  scanf("%d",&n); 
  Remaining=n; 
  for(T4Tutorials_counter=0;T4Tutorials_counter<n;T4Tutorials_counter++) 
  { 
    printf("Enter Arrival Time and Burst Time for Process Process Number %d :",T4Tutorials_counter+1); 
    scanf("%d",&Arrival_Time[T4Tutorials_counter]); 
    scanf("%d",&Burst_Time[T4Tutorials_counter]); 
    rt[T4Tutorials_counter]=Burst_Time[T4Tutorials_counter]; 
  } 
  printf("Enter Time Quantum:\t"); 
  scanf("%d",&time_quantum); 
  printf("\n\nProcess\t|Turnaround Time|Waiting Time\n\n"); 
  for(time=0,T4Tutorials_counter=0;Remaining!=0;) 
  { 
    if(rt[T4Tutorials_counter]<=time_quantum && rt[T4Tutorials_counter]>0) 
    { 
      time+=rt[T4Tutorials_counter]; 
      rt[T4Tutorials_counter]=0; 
      flag=1; 
    } 
    else if(rt[T4Tutorials_counter]>0) 
    { 
      rt[T4Tutorials_counter]-=time_quantum; 
      time+=time_quantum; 
    } 
    if(rt[T4Tutorials_counter]==0 && flag==1) 
    { 
      Remaining--; 
      printf("P[%d]\t|\t%d\t|\t%d\n",T4Tutorials_counter+1,time-Arrival_Time[T4Tutorials_counter],time-Arrival_Time[T4Tutorials_counter]-Burst_Time[T4Tutorials_counter]); 
      wait_time+=time-Arrival_Time[T4Tutorials_counter]-Burst_Time[T4Tutorials_counter]; 
      turnaround_time+=time-Arrival_Time[T4Tutorials_counter]; 
      flag=0; 
    } 
    if(T4Tutorials_counter==n-1) 
      T4Tutorials_counter=0; 
    else if(Arrival_Time[T4Tutorials_counter+1]<=time) 
      T4Tutorials_counter++; 
    else 
      T4Tutorials_counter=0; 
  } 
  printf("\nAverage Waiting Time= %f\n",wait_time*1.0/n); 
  printf("Avg Turnaround Time = %f",turnaround_time*1.0/n); 
  
  return 0; 
}

#include<stdio.h>

int main()

{

int T4Tutorials_counter,j,n,time,Remaining,flag=0,time_quantum;

int wait_time=0,turnaround_time=0,Arrival_Time[10],Burst_Time[10],rt[10];

printf("Enter Total Process:\t ");

scanf("%d",&n);

Remaining=n;

for(T4Tutorials_counter=0;T4Tutorials_counter<n;T4Tutorials_counter++)

{

printf("Enter Arrival Time and Burst Time for Process Process Number %d :",T4Tutorials_counter+1);

scanf("%d",&Arrival_Time[T4Tutorials_counter]);

scanf("%d",&Burst_Time[T4Tutorials_counter]);

rt[T4Tutorials_counter]=Burst_Time[T4Tutorials_counter];

}

printf("Enter Time Quantum:\t");

scanf("%d",&time_quantum);

printf("\n\nProcess\t|Turnaround Time|Waiting Time\n\n");

for(time=0,T4Tutorials_counter=0;Remaining!=0;)

{

if(rt[T4Tutorials_counter]<=time_quantum && rt[T4Tutorials_counter]>0)

{

time+=rt[T4Tutorials_counter];

rt[T4Tutorials_counter]=0;

flag=1;

}

else if(rt[T4Tutorials_counter]>0)

{

rt[T4Tutorials_counter]-=time_quantum;

time+=time_quantum;

}

if(rt[T4Tutorials_counter]==0 && flag==1)

{

Remaining--;

printf("P[%d]\t|\t%d\t|\t%d\n",T4Tutorials_counter+1,time-Arrival_Time[T4Tutorials_counter],time-Arrival_Time[T4Tutorials_counter]-Burst_Time[T4Tutorials_counter]);

wait_time+=time-Arrival_Time[T4Tutorials_counter]-Burst_Time[T4Tutorials_counter];

turnaround_time+=time-Arrival_Time[T4Tutorials_counter];

flag=0;

}

if(T4Tutorials_counter==n-1)

T4Tutorials_counter=0;

else if(Arrival_Time[T4Tutorials_counter+1]<=time)

T4Tutorials_counter++;

else

T4Tutorials_counter=0;

}

printf("\nAverage Waiting Time= %f\n",wait_time*1.0/n);

printf("Avg Turnaround Time = %f",turnaround_time*1.0/n);

return 0;

}

Output

Round robin scheduling program in C++

#include <iostream>
#include <vector>

using namespace std;

int main() {
    int T4Tutorials_counter, j, n, time, Remaining, flag = 0, time_quantum;
    int wait_time = 0, turnaround_time = 0;

    cout << "Enter Total Process:\t ";
    cin >> n;

    Remaining = n;
    vector<int> Arrival_Time(n), Burst_Time(n), rt(n);

    for (T4Tutorials_counter = 0; T4Tutorials_counter < n; T4Tutorials_counter++) {
        cout << "Enter Arrival Time and Burst Time for Process Process Number " << T4Tutorials_counter + 1 << ": ";
        cin >> Arrival_Time[T4Tutorials_counter];
        cin >> Burst_Time[T4Tutorials_counter];
        rt[T4Tutorials_counter] = Burst_Time[T4Tutorials_counter];
    }

    cout << "Enter Time Quantum:\t";
    cin >> time_quantum;

    cout << "\n\nProcess\t|Turnaround Time|Waiting Time\n\n";

    for (time = 0, T4Tutorials_counter = 0; Remaining != 0;) {
        if (rt[T4Tutorials_counter] <= time_quantum && rt[T4Tutorials_counter] > 0) {
            time += rt[T4Tutorials_counter];
            rt[T4Tutorials_counter] = 0;
            flag = 1;
        } else if (rt[T4Tutorials_counter] > 0) {
            rt[T4Tutorials_counter] -= time_quantum;
            time += time_quantum;
        }

        if (rt[T4Tutorials_counter] == 0 && flag == 1) {
            Remaining--;
            cout << "P[" << T4Tutorials_counter + 1 << "]\t|\t" << time - Arrival_Time[T4Tutorials_counter] << "\t|\t" << time - Arrival_Time[T4Tutorials_counter] - Burst_Time[T4Tutorials_counter] << endl;
            wait_time += time - Arrival_Time[T4Tutorials_counter] - Burst_Time[T4Tutorials_counter];
            turnaround_time += time - Arrival_Time[T4Tutorials_counter];
            flag = 0;
        }

        if (T4Tutorials_counter == n - 1)
            T4Tutorials_counter = 0;
        else if (Arrival_Time[T4Tutorials_counter + 1] <= time)
            T4Tutorials_counter++;
        else
            T4Tutorials_counter = 0;
    }

    cout << "\nAverage Waiting Time= " << (float)wait_time / n << endl;
    cout << "Avg Turnaround Time = " << (float)turnaround_time / n << endl;

    return 0;
}

#include <iostream>

#include <vector>

using namespace std;

int main() {

int T4Tutorials_counter, j, n, time, Remaining, flag =

0, time_quantum;

int wait_time = 0, turnaround_time = 0;

cout << "Enter Total Process:\t ";

cin >> n;

Remaining = n;

vector<int> Arrival_Time(n), Burst_Time(n), rt(n);

for (T4Tutorials_counter = 0; T4Tutorials_counter < n; T4Tutorials_counter++) {

cout << "Enter Arrival Time and Burst Time for Process Process Number " << T4Tutorials_counter + 1 << ": ";

cin >> Arrival_Time[T4Tutorials_counter];

cin >> Burst_Time[T4Tutorials_counter];

rt[T4Tutorials_counter] = Burst_Time[T4Tutorials_counter];

}

cout << "Enter Time Quantum:\t";

cin >> time_quantum;

cout << "\n\nProcess\t|Turnaround Time|Waiting Time\n\n";

for (time = 0, T4Tutorials_counter = 0; Remaining != 0;) {

if (rt[T4Tutorials_counter] <= time_quantum && rt[T4Tutorials_counter] > 0) {

time += rt[T4Tutorials_counter];

rt[T4Tutorials_counter] = 0;

flag = 1;

} else if (rt[T4Tutorials_counter] > 0) {

rt[T4Tutorials_counter] -= time_quantum;

time += time_quantum;

}

if (rt[T4Tutorials_counter] == 0 && flag == 1) {

Remaining--;

cout << "P[" << T4Tutorials_counter + 1 << "]\t|\t" << time - Arrival_Time[T4Tutorials_counter] << "\t|\t" << time - Arrival_Time[T4Tutorials_counter] - Burst_Time[

T4Tutorials_counter] << endl;

wait_time += time - Arrival_Time[T4Tutorials_counter] - Burst_Time[T4Tutorials_counter];

turnaround_time += time - Arrival_Time[T4Tutorials_counter];

flag = 0;

}

if (T4Tutorials_counter == n - 1)

T4Tutorials_counter = 0;

else if (Arrival_Time[T4Tutorials_counter + 1] <= time)

T4Tutorials_counter++;

else

T4Tutorials_counter = 0;

}

cout << "\nAverage Waiting Time= " << (float)wait_time / n << endl;

cout << "Avg Turnaround Time = " << (float)turnaround_time / n << endl;

return 0;

}

Round Robin Implementation in Java

Let us see the Round Robin Implementation in Java.

import java.util.*;
class ROUND_ROBIN_SCHEDULING
{
            Scanner sc=new Scanner(System.in);
            int[] bur, wai,ta, extra_variable,;
int t=0;
int flag=0;
 int total_size,q;
int b=0;
            ROUND_ROBIN_SCHEDULING(int total_size)
            {
                        this.total_size=total_size;
                        ta=new int[total_size];
                        extra_variable=new int[total_size];
 
                        bur=new int[total_size];
                        wai=new int[total_size];

            }
            void get()
            {
                        for(int i=0;i<total_size;i++)
                        {
                                    System.out.print("Enter burst time of P"+(i+1)+":");
                                    bur[i]=extra_variable[i]=sc.nextInt();
                        }
                        System.out.print("Enter quantum time:");
                        q=sc.nextInt();
            }
            void round()
            {
                        do{
                                    flag=0;
                                    for(int i=0;i<total_size;i++)
                                    {
                                                if(extra_variable[i]>=q)
                                                {
                                                            System.out.print("P"+(i+1)+"\t");
                                                            for(int j=0;j<total_size;j++)
                                                            {
                                                                        if(j==i)
                                                                                    extra_variable[i]=extra_variable[i]-q;
                                                                        else if(extra_variable[j]>0)
                                                                                    wai[j]+=q;
                                                            }
                                                }
                                                else if(extra_variable[i]>0)
                                                {
                                                            System.out.print("P"+(i+1)+"\t");
                                                            for(int j=0;j<total_size;j++)
                                                            {
                                                                        if(j==i)
                                                                                    extra_variable[i]=0;
                                                                        else if(extra_variable[j]>0)
                                                                                    wai[j]+=extra_variable[i];
                                                            }
                                                }
                                    }
                                    for(int i=0;i<total_size;i++)
                                                if(extra_variable[i]>0)
                                                            flag=1;
                        }while(flag==1);
                        for(int i=0;i<total_size;i++)
                                    ta[i]=wai[i]+bur[i];
            }
            void display()
            {
                        System.out.println("\nProcess\tBurst\tWaiting\tTurnaround");
                        for(int i=0;i<total_size;i++)
                        {
                                    System.out.println("P"+(i+1)+"\t"+bur[i]+"\t"+wai[i]+"\t"+ta[i]);
                                    b+=wai[i];
                                    t+=ta[i];
                        }
                        System.out.println("Average waiting time is?"+(b/total_size));
                        System.out.println("Average Turnaround time is?"+(t/total_size));
            }
}
class KROUND_ROBIN_SCHEDULING
{
            public static void main(String arg[])
            {
                        Scanner s=new Scanner(System.in);
                        System.out.print("Please Enter the total no of process:");
                        int n=s.nextInt();
                        ROUND_ROBIN_SCHEDULING obj = new ROUND_ROBIN_SCHEDULING(n);
                        obj.get();
                        obj.round();
                        obj.display();
            }
}

import java.util.*;

class ROUND_ROBIN_SCHEDULING

{

Scanner sc=new Scanner(System.in);

int[] bur, wai,ta, extra_variable,;

int t=0;

int flag=0;

int total_size,q;

int b=0;

ROUND_ROBIN_SCHEDULING(int total_size)

{

this.total_size=total_size;

ta=new int[total_size];

extra_variable=new int[total_size];

bur=new int[total_size];

wai=new int[total_size];

}

void get()

{

for(int i=0;i<total_size;i++)

{

System.out.print("Enter burst time of P"+(i+1)+":");

bur[i]=extra_variable[i]=sc.nextInt();

}

System.out.print("Enter quantum time:");

q=sc.nextInt();

}

void round()

{

do{

flag=0;

for(int i=0;i<total_size;i++)

{

if(extra_variable[i]>=q)

{

System.out.print("P"+(i+1)+"\t");

for(int j=0;j<total_size;j++)

{

if(j==i)

extra_variable[i]=extra_variable[i]-q;

else if(extra_variable[j]>0)

wai[j]+=q;

}

else if(extra_variable[i]>0)

{

System.out.print("P"+(i+1)+"\t");

for(int j=0;j<total_size;j++)

{

if(j==i)

extra_variable[i]=0;

else if(extra_variable[j]>0)

wai[j]+=extra_variable[i];

}

for(int i=0;i<total_size;i++)

if(extra_variable[i]>0)

flag=1;

}while(flag==1);

for(int i=0;i<total_size;i++)

ta[i]=wai[i]+bur[i];

}

void display()

{

System.out.println("\nProcess\tBurst\tWaiting\tTurnaround");

for(int i=0;i<total_size;i++)

{

System.out.println("P"+(i+1)+"\t"+bur[i]+"\t"+wai[i]+"\t"+ta[i]);

b+=wai[i];

t+=ta[i];

}

System.out.println("Average waiting time is?"+(b/total_size));

System.out.println("Average Turnaround time is?"+(t/total_size));

}

class KROUND_ROBIN_SCHEDULING

{

public static void main(String arg[])

{

Scanner s=new Scanner(System.in);

System.out.print("Please Enter the total no of process:");

int n=s.nextInt();

ROUND_ROBIN_SCHEDULING obj = new ROUND_ROBIN_SCHEDULING(n);

obj.get();

obj.round();

obj.display();

}

Round Robin Process Scheduling algorithm in operating systems
By: Prof. Dr. Fazal Rehman | Last updated: July 28, 2024

Examples of Round-robin scheduling

Advantage of Round-robin Scheduling

Disadvantages of Round-robin Scheduling

Round robin scheduling program in C

Round robin scheduling program in C++

Round Robin Implementation in Java

Exercise on Round Robin Process Scheduling algorithm with Solution

Related Posts:

Leave a Comment