Lab-Two

Implementation of CPU Scheduling Algorithms (FCFS, SJF, RR,

Priority, SRTF)
 Programming Language: C++
 Compiler: Dev-C++
 Platform: windows 10

1. Implementing of FCFS CPU Scheduling Algorithms

#include<iostream>

#define MAX_PROCESS 10

using namespace std;

class process

public:

int process_num;

int burst_time;

int arrival_time;

int response_time;

int waiting_time;

int turnaround_time;

void input_process(int);

int get_at()

return arrival_time;

};
void process::input_process(int count)

process_num=count+1;

cout<<"\nENTER BURST TIME FOR PROCESS "<<count+1<<" : ";

cin>>burst_time;

cout<<"ENTER ARRIVAL TIME FOR PROCESS "<<count+1<<" : ";

cin>>arrival_time;

void calc_wait_tat(process*,int);

void average(process*,int);

void display(process*,int);

int main()

process p[MAX_PROCESS],temp;

int num,i,j;

cout<<"ENTER NUMBER OF PROCESSES : ";

cin>>num;

for(i=0;i<num;++i)

p[i].input_process(i);

for(i=0;i<num;++i)

for(j=i+1;j<num;++j)

if(p[i].get_at()>p[j].get_at())

temp=p[i];
 p[i]=p[j];

p[j]=temp;

calc_wait_tat(p,num);

display(p,num);

return 0;

void calc_wait_tat(process *p,int n)

int i;

p[0].response_time=0;

for(i=1;i<n;++i)

p[i].response_time=p[i-1].burst_time+p[i-1].response_time;

if(p[i].response_time<p[i].arrival_time)

p[i].response_time=p[i].arrival_time;

p[0].waiting_time=0;

for(i=1;i<n;++i)

p[i].waiting_time=p[i].response_time-p[i].arrival_time;

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

p[i].turnaround_time=p[i].waiting_time+p[i].burst_time;

void average(process *p,int n)

{

float avg_wt=0,avg_tat=0;

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

avg_wt+=(float)p[i].waiting_time;

avg_tat+=(float)p[i].turnaround_time;

avg_wt/=n;

avg_tat/=n;

cout<<"\n\nAVERAGE WAITING TIME : "<<avg_wt;

cout<<"\nAVERAGE TURN AROUND TIME : "<<avg_tat;

void display(process *p,int n)

cout<<"Processes "<<" Burst time "<<" Waiting time "<<" Turn around time\n";

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

cout<<"\n "<<p[i].process_num<<"\t\t"<<p[i].burst_time<<"\t "<<p[i].waiting_time<<"\t\t

"<<p[i].turnaround_time;

average(p,n);

2. Implementing of SJF CPU Scheduling Algorithms

#include<iostream>

#include<iomanip>

using namespace std;

class sjf_alg
{

int exe[10],id[10];

int n;

void sort(int *,int*);

public:

void getdata();

void display();

void cal_wt_tt();

};

void sjf_alg::getdata()

cout<<"How many processes to be entered : ";

cin>>n;

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

cout<<"Enter execution time of "<<i+1<<" process : ";

cin>>exe[i];

id[i]=i+1;

void sjf_alg::display()

cout<<endl<<"Process ID\tExecution time\tArrival Time "<<endl;

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

cout<<setw(5)<<i+1<<setw(15)<<exe[i]<<setw(15)<<"0"<<endl;

}
void sjf_alg::sort(int *f,int *l)

int temp;

for(int y=0;y<n-1;y++)

for(int z=0;z<n-1;z++)

if(f[z]>f[z+1])

temp=f[z];

f[z]=f[z+1];

f[z+1]=temp;

temp=l[z];

l[z]=l[z+1];

l[z+1]=temp;

void sjf_alg::cal_wt_tt()

int wt=0,tnt=0;

float avg=0,avtnt=0;

sort(exe,id);

cout<<"\nProcess ID \tWaiting time \tTurn Around time "<<endl;

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

tnt+=exe[i];
 avtnt+=tnt;

avg+=wt;

cout<<setw(5)<<id[i]<<setw(15)<<wt<<setw(15)<<tnt<<endl;

wt+=exe[i];

avg=avg/(float)n;

avtnt/=(float)n;

cout<<"\nAverage Waiting time : "<<avg;

cout<<"\nAverage turn Around time : "<<avtnt<<endl;

int main()

sjf_alg sjf;

sjf.getdata();

sjf.display();

sjf.cal_wt_tt();

return 0;

3. Implementing of Priority CPU Scheduling Algorithms

#include<iostream>

using namespace std;

int main()

int bt[20],p[20],wt[20],tat[20],pr[20],i,j,n,total=0,pos,temp,avg_wt,avg_tat;

cout<<"Enter Total Number of Process:";

cin>>n;
cout<<"\nEnter Burst Time and Priority\n";

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

cout<<"\nP["<<i+1<<"]\n";

cout<<"Burst Time:";

cin>>bt[i];

cout<<"Priority:";

cin>>pr[i];

p[i]=i+1; //contains process number

//sorting burst time, priori\ty and process number in ascending order using selection sort

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

pos=i;

for(j=i+1;j<n;j++)

if(pr[j]<pr[pos])

pos=j;

temp=pr[i];

pr[i]=pr[pos];

pr[pos]=temp;

temp=bt[i];

bt[i]=bt[pos];

bt[pos]=temp;
 temp=p[i];

p[i]=p[pos];

p[pos]=temp;

wt[0]=0; //waiting time for first process is zero

//calculate waiting time

for(i=1;i<n;i++)

wt[i]=0;

for(j=0;j<i;j++)

wt[i]+=bt[j];

total+=wt[i];

avg_wt=total/n; //average waiting time

total=0;

cout<<"\nProcess\t Burst Time \tWaiting Time\tTurnaround Time";

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

tat[i]=bt[i]+wt[i]; //calculate turnaround time

total+=tat[i];

cout<<"\nP["<<p[i]<<"]\t\t "<<bt[i]<<"\t\t "<<wt[i]<<"\t\t\t"<<tat[i];

avg_tat=total/n; //average turnaround time

 cout<<"\n\nAverage Waiting Time="<<avg_wt;

cout<<"\nAverage Turnaround Time="<<avg_tat;

return 0;

4. Implementing of Round Robin CPU Scheduling Algorithms

#include<iostream>

#include<cstdlib>

#include<queue>

#include<cstdio>

using namespace std;

/* C++ Program to Round Robin*/

typedef struct process

int id,at,bt,st,ft,pr;

float wt,tat;

}process;

process p[10],p1[10],temp;

queue<int> q1;

int accept(int ch);

void turnwait(int n);

void display(int n);

void ganttrr(int n);

int main()

int i,n,ts,ch,j,x;

p[0].tat=0;

p[0].wt=0;

n=accept(ch);

ganttrr(n);

turnwait(n);

display(n);

return 0;

int accept(int ch)

int i,n;

printf("Enter the Total Number of Process: ");

scanf("%d",&n);

if(n==0)

{
 printf("Invalid");

exit(1);

cout<<endl;

for(i=1;i<=n;i++)

printf("Enter an Arrival Time of the Process P%d: ",i);

scanf("%d",&p[i].at);

p[i].id=i;

cout<<endl;

for(i=1;i<=n;i++)

printf("Enter a Burst Time of the Process P%d: ",i);

scanf("%d",&p[i].bt);

for(i=1;i<=n;i++)

p1[i]=p[i];

return n;
}

void ganttrr(int n)

int i,ts,m,nextval,nextarr;

nextval=p1[1].at;

i=1;

cout<<"\nEnter the Time Slice or Quantum: ";

cin>>ts;

for(i=1;i<=n && p1[i].at<=nextval;i++)

q1.push(p1[i].id);

while(!q1.empty())

m=q1.front();

q1.pop();

if(p1[m].bt>=ts)

nextval=nextval+ts;

}
 else

nextval=nextval+p1[m].bt;

if(p1[m].bt>=ts)

p1[m].bt=p1[m].bt-ts;

else

p1[m].bt=0;

while(i<=n&&p1[i].at<=nextval)

q1.push(p1[i].id);

i++;

if(p1[m].bt>0)

q1.push(m);

if(p1[m].bt<=0)

p[m].ft=nextval;
 }

void turnwait(int n)

int i;

for(i=1;i<=n;i++)

p[i].tat=p[i].ft-p[i].at;

p[i].wt=p[i].tat-p[i].bt;

p[0].tat=p[0].tat+p[i].tat;

p[0].wt=p[0].wt+p[i].wt;

p[0].tat=p[0].tat/n;

p[0].wt=p[0].wt/n;

void display(int n)

int i;

/*

Here

at = Arrival time,

bt = Burst time,

time_quantum= Quantum time

tat = Turn around time,

wt = Waiting time

*/

cout<<"\n=====================================================\n";

cout<<"\n\nHere AT = Arrival Time\nBT = Burst Time\nTAT = Turn Around Time\nWT = Waiting

Time\n";

cout<<"\n===================TABLE==============================\n";

printf("\nProcess\tAT\tBT\tFT\tTAT\t\tWT");

for(i=1;i<=n;i++)

printf("\nP%d\t%d\t%d\t%d\t%f\t%f",p[i].id,p[i].at,p[i].bt,p[i].ft,p[i].tat,p[i].wt);

cout<<"\n=====================================================\n";

printf("\nAverage Turn Around Time: %f",p[0].tat);

printf("\nAverage Waiting Time: %f\n",p[0].wt);

5. Implementing of Shortest Remaining Time First (SRTF) Algorithm

#include <iostream>
#include <algorithm>
#include <iomanip>
#include <string.h>
using namespace std;
struct process {
int pid;
int arrival_time;
int burst_time;
int start_time;
 int completion_time;
int turnaround_time;
int waiting_time;
int response_time;
};
int main() {

int x;
struct process p[100];
float avg_turnaround_time;
float avg_waiting_time;
float avg_response_time;
float cpu_utilization;
int total_turnaround_time = 0;
int total_waiting_time = 0;
int total_response_time = 0;
int total_idle_time = 0;
float throughput;
int burst_remaining[100];
int is_completed[100];
memset(is_completed,0,sizeof(is_completed));

cout << setprecision(2) << fixed;

cout<<"Enter the number of processes: ";

cin>>x;

for(int i = 0; i < x; i++) {

cout<<"Enter arrival time ofthe process "<<i+1<<": ";
cin>>p[i].arrival_time;
cout<<"Enter burst time of the process "<<i+1<<": ";
cin>>p[i].burst_time;
p[i].pid = i+1;
burst_remaining[i] = p[i].burst_time;
cout<<endl;
}

int current_time = 0;
int completed = 0;
int prev = 0;
while(completed != x) {
int idx = -1;
int mn = 10000000;
for(int i = 0; i < x; i++) {
if(p[i].arrival_time <= current_time && is_completed[i] == 0) {
if(burst_remaining[i] < mn) {
mn = burst_remaining[i];
idx = i;
}
if(burst_remaining[i] == mn) {
if(p[i].arrival_time < p[idx].arrival_time) {
mn = burst_remaining[i];
idx = i;
}
}
}
}

if(idx != -1) {
if(burst_remaining[idx] == p[idx].burst_time) {
p[idx].start_time = current_time;
total_idle_time += p[idx].start_time - prev;
}
burst_remaining[idx] -= 1;
current_time++;
prev = current_time;

if(burst_remaining[idx] == 0) {
p[idx].completion_time = current_time;
p[idx].turnaround_time = p[idx].completion_time - p[idx].arrival_time;
p[idx].waiting_time = p[idx].turnaround_time - p[idx].burst_time;
p[idx].response_time = p[idx].start_time - p[idx].arrival_time;

total_turnaround_time += p[idx].turnaround_time;
total_waiting_time += p[idx].waiting_time;
total_response_time += p[idx].response_time;

is_completed[idx] = 1;
completed++;
}
}
 else {
current_time++;
}
}

int min_arrival_time = 10000000;

int max_completion_time = -1;
for(int i = 0; i < x; i++) {
min_arrival_time = min(min_arrival_time,p[i].arrival_time);
max_completion_time = max(max_completion_time,p[i].completion_time);
}
avg_turnaround_time = (float) total_turnaround_time / x;
avg_waiting_time = (float) total_waiting_time / x;
avg_response_time = (float) total_response_time / x;
cpu_utilization = ((max_completion_time - total_idle_time) / (float)
max_completion_time )*100;
throughput = float(x) / (max_completion_time - min_arrival_time);

cout<<endl<<endl;

cout<<"Process\t"<<"Arrival Time\t"<<"Burst Time\t"<<"ST\t"<<"CT\t"<<"TAT\

t"<<"WT\t"<<"RT\t"<<"\n"<<endl;

for(int i = 0; i < x; i++) {

cout<<p[i].pid<<"\t"<<p[i].arrival_time<<"\t"<<p[i].burst_time<<"\
t"<<p[i].start_time<<"\t"<<p[i].completion_time<<"\t"<<p[i].turnaround_time<<"\
t"<<p[i].waiting_time<<"\t"<<p[i].response_time<<"\t"<<"\n"<<endl;
}
cout<<"Average Turnaround Time = "<<avg_turnaround_time<<endl;
cout<<"Average Waiting Time = "<<avg_waiting_time<<endl;
cout<<"Average Response Time = "<<avg_response_time<<endl;
cout<<"CPU Utilization = "<<cpu_utilization<<"%"<<endl;
cout<<"Throughput = "<<throughput<<" process/unit time"<<endl;