Ex. No.: 6(a)
|
SIMULATION
OF CPU SCHEDULING ALGORITHMS - ROUND
ROBIN SCHEDULING
|
AIM
To simulate CPU scheduling, using Round Robin (RR) Scheduling algorithm.
Description:
In
this Scheduling processes are dispatched FIFO but are given a limited amount of
CPU time called a time-slice or quantum. If a process does not complete before
its CPU time expires, the CPU preempted and given to the next waiting process.
The preempted process is then placed the back of the ready list. . It depicts
the order in which the processes are executed, calculates the turnaround time
and average waiting time of the processes
Algorithm:
- Start
of algorithm
2. Declare the required variables and functions.
3. Get the number of processors, process name, and burst time for each process.
- Get
the time quantum from the user.
- First
process is taken and executed for the time quantum.
- Take
the next process is taken and executed up to the time quantum.
- After
the last process is executed the first process is taken in circular fashion.
If the burst time is over the current process is skipped and next process
is executed.
- Steps
(5) and (6) are repeated till the burst time of all processes gets over.
- Calculate
the waiting time for each process. And calculate the average waiting from
the waiting time of each process.
- Stop
of algorithm.
Program
#include<stdio.h>
//Function Prototype
void enqueue(int p);
int dequeue();
//Global variables
int queue[10];
int wttime[10];
int time=0;
int remain[10];
int end=-1,len=0;
int main()
{
int n,i,tq;
float avgt=0,temp,avgw=0;
int burst[10],wait[10],process[10];
int rtemp,ptemp;
printf("\nProcess Scheduling(Round Robin)");
printf("\nEnter the number of process : ");
scanf("%d",&n);
printf("\nEnter the Burst time\n");
for(i=0;i<n;i++)
{
printf("\nBurst time P%d : ",i+1);
scanf("%d",&burst[i]);
process[i] = i;
remain[i] = burst[i];
wttime[i] = 0;
enqueue(i);
}
printf("\nEnter the time quantum(TQ) : ");
scanf("%d",&tq);
printf("\nProcess Name : Time Executed : Remaining Time \n");
while(len > 0)
{
ptemp = dequeue();
rtemp = remain[ptemp];
if(rtemp > tq)
{
wttime[ptemp] = time - (burst[ptemp] - remain[ptemp]);
remain[ptemp] = rtemp - tq;
enqueue(ptemp);
printf("\n P%d \t\t\t %d \t\t %d",ptemp+1,tq,remain[ptemp]);
time += tq;
}
if(rtemp == tq)
{
wttime[ptemp] = time - (burst[ptemp] - remain[ptemp]);
remain[ptemp] = 0;
printf("\n P%d \t\t\t %d \t\t %d",ptemp+1,tq,remain[ptemp]);
time += tq;
}
if(rtemp < tq)
{
wttime[ptemp] = time - (burst[ptemp] - remain[ptemp]);
remain[ptemp] = 0;
printf("\n P%d \t\t\t %d \t\t %d",ptemp+1,rtemp,remain[ptemp]);
time += rtemp;
}
}
printf("\n\nProcess Name : Wait Time : Turn around Time\n");
for(i = 0;i < n; i++)
{
printf("\n P%d \t\t\t %d \t\t %d",i+1,wttime[i],wttime[i] + burst[i]);
avgw+=wttime[i];
avgt+=(wttime[i] + burst[i]);
}
printf("\n\nAverage Wait Time = %f",avgw/n);
printf("\nAverage Turn around Time = %f",avgt/n);
return 0;
}
void enqueue(int p)
{
end++;
len++;
queue[end] = p;
}
int dequeue()
{
int i;
int temp;
temp = queue[0];
for(i = 0;i < len-1;i++)
{
queue[i] = queue[i+1];
}
end--;
len--;
return temp;
}
[jeyakumar@localhost ~]$ cc rr1.c
[jeyakumar@localhost ~]$ ./a.out
Process Scheduling(Round Robin)
Enter the number of process : 3
Enter the Burst time
Burst time P1 : 21
Burst time P2 : 45
Burst time P3 : 24
Enter the time quantum (TQ): 7
Process Name : Time Executed: Remaining Time
P1 7 14
P2 7 38
P3 7 17
P1 7 7
P2 7 31
P3 7 10
P1 7 0
P2 7 24
P3 7 3
P2 7 17
P3 3 0
P2 7 10
P2 7 3
P2 3 0
Process Name : Wait Time : Turn around Time
P1 28 49
P2 45 90
P3 49 73
Average Wait Time = 40.667
Average Turn around Time = 70.667
No comments:
Post a Comment