Question

Write a C++ (or Java) program for Round Robin scheduling as following:

Round Robin is a CPU scheduling algorithm where each process is assigned a fixed time slot in a

cyclic way.

• It is simple, easy to implement, and starvation-free as all processes get fair share of CPU.

• One of the most commonly used technique in CPU scheduling as a core.

• It is preemptive as processes are assigned CPU only for a fixed slice of time at most.

• The disadvantage of it is more overhead of context switching.

To compute the associated times in Round Robin:

1. Completion Time: Time at which process completes its execution.

2. Turn Around Time: Time Difference between completion time and arrival time.

Turn Around Time = Completion Time – Arrival Time

3. Waiting Time (W.T): Time Difference between turnaround time and burst time.

Waiting Time = Turn Around Time – Burst Time

Assume the arrival times are 0 second so that turnaround and completion times are same.

Once waiting times are computed, turnaround times can be quickly computed.

Steps to find waiting times of all processes:

1. Create an array rem_bt[ ] to keep track of remaining burst time of processes.

This array is initially a copy of bt[ ] (burst times array)

2. Create another array wt[ ] to store waiting times of processes. Initialize this array as 0.

3. Initialize time: t = 0.

4. Keep traversing the all processes while all processes are not done. Do following for ith

process if it is not done yet.

If rem_bt[i] > quantum

(i) t = t + quantum

(ii) bt_rem[i] -= quantum;

Else // Last cycle for this process

(i) t = t + bt_rem[i];

(ii) wt[i] = t - bt[i]

(ii) bt_rem[i] = 0; // This process is over

Once we have waiting times, we can compute turnaround time tat[i] of a process as sum of

waiting and burst times, i.e., wt[i] + bt[i]

Answer 1

main.cpp

#include<iostream>

using namespace std;

struct processes

{

int nums;

int arrival,estimated,wait,total;

int est;

int time;

};

int main()

{

processes arr[99];

int x,y,z;

cout<<"Please enter the total number of processes:"<<endl;

int processNum;

cin>>processNum;

for (x=0;x<processNum;x++)

{

cout<<"Please enter the execution time of processes "<<x+1<<":"<<endl;

cin>>arr[x].estimated;

arr[x].est=arr[x].estimated;

arr[x].arrival=arr[x].time=arr[x].total=arr[x].wait=0;

arr[x].nums=x+1;

}

cout<<"Please enter the time quantum:"<<endl;

int a;

cin>>a;

cout<<"The entered data is as follows: "<<endl;

cout<<"Processes\tET"<<endl;

for(x=0;x<processNum;x++)

{

cout<<endl;

    cout<<arr[x].nums<<"\t\t\t"<<arr[x].estimated;

}

int totaltime=0;

for(x=0;x<processNum;x++)

{

totaltime+=arr[x].estimated;

}

x=0;

z=0;

int rrg[99];

for(y=0;y<totaltime;y++)

{

if((z==0)&&(arr[x].estimated!=0))

{

arr[x].wait=y;

if((arr[x].time!=0))

{

arr[x].wait-=a*arr[x].time;

}

}

if((arr[x].estimated!=0)&&(z!=a))

{

rrg[y]=arr[x].nums;

arr[x].estimated-=1;

z++;

}

else

{

if((z==a)&&(arr[x].estimated!=0))

{

arr[x].time+=1;

}

x=x+1;

if(x==processNum)

{

x=0;

}

z=0;

y=y-1;

}

}

int waitTotal=0;

int timeTotal=0;

cout<<endl;

cout<<"Final result of round robin scheduling: "<<endl;

cout<<"Process Id\tEstimated Time\tWait Time\tTurn around Time";

for(x=0;x<processNum;x++)

{

arr[x].total=arr[x].wait+arr[x].est;

timeTotal+=arr[x].total;

waitTotal+=arr[x].wait;

cout<<endl;

    cout<<arr[x].nums<<"\t\t"<<"\t\t"<<arr[x].est<<"\t\t\t\t"<<arr[x].wait<<"\t\t\t\t"<<arr[x].total<<endl;

}

cout<<endl;

cout<<"Average Waiting Time: "<<(float)waitTotal/processNum<<endl;

cout<<"Average Turn Around Time: "<<(float)timeTotal/processNum<<endl;

return 0;

}

Output: