Scribd
Upload
28 views10 pages

Ex - No.5 CPU Sceduling

This document discusses and provides code to simulate four CPU scheduling algorithms: First Come First Serve (FCFS), Round Robin, Shortest Job First (SJF), and Priority Scheduling. For each algorithm, it includes the programming code in C to implement the algorithm, sample input/output, and calculates metrics like waiting time and turnaround time. The aim is to simulate and compare different process scheduling techniques.

Uploaded by

Anbuselvi S
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
28 views10 pages

Ex - No.5 CPU Sceduling

This document discusses and provides code to simulate four CPU scheduling algorithms: First Come First Serve (FCFS), Round Robin, Shortest Job First (SJF), and Priority Scheduling. For each algorithm, it includes the programming code in C to implement the algorithm, sample input/output, and calculates metrics like waiting time and turnaround time. The aim is to simulate and compare different process scheduling techniques.

Uploaded by

Anbuselvi S
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 10

SIMULATION OF CPU SCHEDULING ALGORITHMS

AIM :
To implement the process scheduling using First Come, First Served (FCFS), Round
Robin (RR), Shortest Job First (SJB) and Priority Scheduling Algorithms.

(i) FIRST COME FIRST SERVE (FCFS) :


PROGRAM :
#include<stdio.h>

int main()

{
intn,bt[20],wt[20],tat[20],avwt=0,avtat=0,i,j;
printf("Enter total number of processes(maximum 20):");
scanf("%d",&n);

printf("\nEnter Process Burst Time\n");


for(i=0;i<n;i++)
{
printf("P[%d]:",i+1);
scanf("%d",&bt[i]);
}

wt[0]=0;

for(i=1;i<n;i++)
{
wt[i]=0;
for(j=0;j<i;j++)
wt[i]+=bt[j];
}

printf("\nProcess\t\tBurst Time\tWaiting Time\tTurnaround Time");


for(i=0;i<n;i++)
{
tat[i]=bt[i]+wt[i];//Turnaround Time = Burst time-waiting Time
avwt+=wt[i];
avtat+=tat[i];
printf("\nP[%d]\t\t%d\t\t%d\t\t%d",i+1,bt[i],wt[i],tat[i]);
}

avwt/=i;
avtat/=i;
printf("\n\nAverage Waiting Time:%d",avwt);
printf("\nAverage Turnaround Time:%d",avtat);

return 0;
}

OUTPUT :

(ii) ROUND ROBIN :


PROGRAM :
#include<stdio.h>
int main()
{
int i, limit, total = 0, x, counter = 0, time_quantum;
intwait_time = 0, turnaround_time = 0, arrival_time[10], burst_time[10], temp[10];
float average_wait_time, average_turnaround_time;
printf("\nEnter Total Number of Processes: ");
scanf("%d", &limit);
x = limit;
for(i = 0; i < limit; i++)
{
printf("\nEnter Details of Process[%d]", i + 1);
printf("\nArrival Time:");
scanf("%d", &arrival_time[i]);
printf("\nBurst Time:");
scanf("%d", &burst_time[i]);
temp[i] = burst_time[i];
}

printf("\nEnter Time Quantum: ");


scanf("%d", &time_quantum);
printf("\nProcess ID\t\tBurst Time\t Turnaround Time\tWaiting Time: ");
for(total = 0, i = 0; x != 0;)
{
if(temp[i] <= time_quantum&& temp[i] > 0)
{
total = total + temp[i];
temp[i] = 0;
counter = 1;
}
else if(temp[i] > 0)
{
temp[i] = temp[i] - time_quantum;
total = total + time_quantum;
}
if(temp[i] == 0 && counter == 1)
{
x--;
printf("\n\nProcess[%d]\t\t%d\t\t %d\t\t\t %d", i + 1, burst_time[i], total -
arrival_time[i], total - arrival_time[i] - burst_time[i]);
wait_time = wait_time + total - arrival_time[i] - burst_time[i];
turnaround_time = turnaround_time + total - arrival_time[i];
counter = 0;
}
if(i == limit - 1)
{
i = 0;
}
else if(arrival_time[i + 1] <= total)
{
i++;
}
else
{
i = 0;
}
}

average_wait_time = wait_time * 1.0 / limit;


average_turnaround_time = turnaround_time * 1.0 / limit;
printf("\nAverage Waiting Time:\t%f", average_wait_time);
printf("\n\nAverage Turnaround Time:\t%f\n", average_turnaround_time);
return 0;
}

OUTPUT :

(iii) SHORTEST JOB FIRST (SJB) :


PROGRAM :
#include <stdio.h>
int main()
{
int A[100][4]; // Matrix for storing Process Id, Burst
// Time, Average Waiting Time & Average
// Turn Around Time.
int i, j, n, total = 0, index, temp;
float avg_wt, avg_tat;
printf("Enter number of process: ");
scanf("%d", &n);
printf("Enter Burst Time:\n");
// User Input Burst Time and alloting Process Id.
for (i = 0; i < n; i++) {
printf("P%d: ", i + 1);
scanf("%d", &A[i][1]);
A[i][0] = i + 1;
}
// Sorting process according to their Burst Time.
for (i = 0; i < n; i++) {
index = i;
for (j = i + 1; j < n; j++)
if (A[j][1] < A[index][1])
index = j;
temp = A[i][1];
A[i][1] = A[index][1];
A[index][1] = temp;

temp = A[i][0];
A[i][0] = A[index][0];
A[index][0] = temp;
}
A[0][2] = 0;
// Calculation of Waiting Times
for (i = 1; i < n; i++) {
A[i][2] = 0;
for (j = 0; j <i; j++)
A[i][2] += A[j][1];
total += A[i][2];
}
avg_wt = (float)total / n;
total = 0;
printf("P BT WT TAT\n");
// Calculation of Turn Around Time and printing the
// data.
for (i = 0; i < n; i++) {
A[i][3] = A[i][1] + A[i][2];
total += A[i][3];
printf("P%d %d %d %d\n", A[i][0],
A[i][1], A[i][2], A[i][3]);
}
avg_tat = (float)total / n;
printf("Average Waiting Time= %f", avg_wt);
printf("\nAverage Turnaround Time= %f", avg_tat);
}

OUTPUT :
(iv) PRIORITY SCHEDULING :
PROGRAM :
#include <stdio.h>

//Function to swap two variables


void swap(int *a,int *b)
{
int temp=*a;
*a=*b;
*b=temp;
}
int main()
{
int n;
printf("Enter Number of Processes: ");
scanf("%d",&n);

// b is array for burst time, p for priority and index for process id
int b[n],p[n],index[n];
float avg_wt = 0, avg_tat = 0;
for(int i=0;i<n;i++)
{
printf("Enter Burst Time and Priority Value for Process %d: ",i+1);
scanf("%d %d",&b[i],&p[i]);
index[i]=i+1;
}
for(int i=0;i<n;i++)
{
int a=p[i],m=i;

//Finding out highest priority element and placing it at its desired position
for(int j=i;j<n;j++)
{
if(p[j] > a)
{
a=p[j];
m=j;
}
}

//Swapping processes
swap(&p[i], &p[m]);
swap(&b[i], &b[m]);
swap(&index[i],&index[m]);
}

// T stores the starting time of process


int t=0;
//Printing scheduled process
printf("Order of process Execution is\n");
for(int i=0;i<n;i++)
{
printf("P%d is executed from %d to %d\n",index[i],t,t+b[i]);
t+=b[i];
}
printf("\n");
printf("Process Id Burst Time Wait Time TurnAround Time\n");
intwait_time=0;
for(int i=0;i<n;i++)
{
printf("P%d %d %d %d\n",index[i],b[i],wait_time,wait_time + b[i]);
avg_wt += wait_time;
wait_time += b[i];
avg_tat += wait_time + b[i];
}
avg_wt /= n;
avg_tat /= n;
printf(“\n\nAverage Waiting Time : %f “, avg_wt);
printf(“\nAvergae Turnaround Time : %f “, avg_tat);
return 0;
}

OUTPUT :
RESULT :
Thus, the process scheduling were implemented using FCFS, Round Robin, SJB and
Priority Scheduling Algorithms.

You might also like