IMPLEMENTATION OF CPU-SCHEDULING ALGORITHMS-ROUND ROBIN AND PRIORITY

PROGRAM CODING:-

#include<stdio.h>
#include<stdlib.h>
struct job_type
{ char name[10];
float arrival,burst,wait,turnaround;
int priority;
};
typedef struct job_type job;
void readprocess(job* b,int n)
{ int i;
for(i=0;i<n;i++)
{ printf("\nEnter the process id of the process %d:",i+1);
scanf("%s",b[i].name);
printf("Enter arrival time:");
scanf("%f",&(b[i].arrival));
printf("Enter burst time:");
scanf("%f",&(b[i].burst));
printf("Enter priority:");
scanf("%d",&(b[i].priority));
}
}
void swap(job* jp,int i,int j)
{ job g;
g=jp[i];
jp[i]=jp[j];
jp[j]=g;
}
int sortcheck(job* jp,int j,int k)
{ if(k==1)
  if(jp[j].arrival > jp[j+1].arrival)
  return 1;
  else return 0;
else if(k==2)
   if(jp[j].arrival > jp[j+1].arrival||(jp[j].arrival==jp[j+1].arrival &&jp[j].priority > jp[j+1].priority))
    return 1;
   else return 0;
}
void sort(job* jp,int n,int k)
{ int i,j;
job g;
for(i=0;i<n-1;i++)


for(j=0;j<n-i-1;j++)
  if(sortcheck(jp,j,k))
  swap(jp,j,j+1);
}
void display(job* jp,int n)
{ int i,s;
float sumw,sumt;
sumw=sumt=0;
printf("----------------------------------------------------------------------------------------");
printf("\nProcess Id    Arrival Time    Burst Time   Priority   Waiting Time    Turnaround Time\n");
printf("----------------------------------------------------------------------------------------\n");
for(i=0;i<n;i++)
{ printf("%10.2s%16.2f%12.2f%10d%17.2f%20.2f\n",jp[i].name,jp[i].arrival,jp[i].burst,jp[i].priority,jp[i].wait,jp[i].turnaround);
sumw+=jp[i].wait;
sumt+=jp[i].turnaround;
}
sumw/=n;sumt/=n;
printf("---------------------------------------------------------------------------------------\n");
printf("                                            Average%14.4f%19.4f\n",sumw,sumt);
printf("                                            ---------------------------------------------");

}
void roundrobin(job* jp,int n,float min)
{ int i,s,*w,k=0,times[30]; float j=0,time[30];
w=(int*)malloc(sizeof(int)*n);
for(i=0,s=0;i<n;i++)
{  w[i]=jp[i].burst;
  s+=jp[i].burst;
}
while(j<s)
for(i=0;i<n;i++)
if(jp[i].arrival<=j&&w[i]>0)
{ times[k]=i;
w[i]-=min;
j+=min;
if(w[i]<=0)
{jp[i].turnaround=j+w[i]-jp[i].arrival;
jp[i].wait=jp[i].turnaround-jp[i].burst;
j+=w[i];
}
time[k++]=j;
}
free(w);
display(jp,n);
printf("\n\nGANTT CHART\n\t");
for(i=0;i<k;i++)
printf("------");
printf("\n\t|");
for(i=0;i<k;i++)
printf("%3s%3c",jp[times[i]].name,'|');


printf("\n\t");
for(i=0;i<k;i++)
printf("------");
printf("\n\t0");
for(i=0;i<k;i++)
if(time[i]>9)
 printf("  %0.1f",time[i]);
else
 printf("   %0.1f",time[i]);
}
void nonpreempt(job* jp,int n)
{ int i,j=0,small,time[10];
job g;
float s=0;
for(i=1;i<n-1;i++)
if(jp[j].arrival > jp[i].arrival)
j=i;
else if(jp[j].arrival==jp[i].arrival && jp[i].priority < jp[j].priority)
j=i;
jp[0].wait=0;
jp[0].turnaround=jp[0].burst;
time[0]=jp[0].burst;
for(i=0,s=jp[0].burst;i<n-1;i++)
  { for(j=i+1,small=i+1;j<n;j++)
  if(jp[j].arrival <=s && jp[j].priority < jp[small].priority)//check the smallest priority 
small=j;
else if(jp[j].priority==jp[small].priority&& jp[j].arrival < jp[small].arrival)//if equal priority, check earlier arrival
small=j;
swap(jp,i+1,small);
jp[i+1].wait=s-jp[i+1].arrival;
jp[i+1].turnaround=jp[i+1].wait + jp[i+1].burst;
s+=jp[i+1].burst;
time[i+1]=s; 
  }
display(jp,n);
printf("\n\nGANTT CHART\n\t");
for(i=0;i<n;i++)
printf("--------");
printf("\n\t|");
for(i=0;i<n;i++)
printf("%4s%4c",jp[i].name,'|');
printf("\n\t");
for(i=0;i<n;i++)
printf("--------");
printf("\n\t0");
for(i=0;i<n;i++)
if(time[i]>9)
 printf("      %d",time[i]);
else
 printf("       %d",time[i]);
}


int chk(int* w,int n)
{ int i;
for(i=0;i<n;i++)
if(w[i]!=0)
return 1;
return 0;
}
void preempt(job* jp,int n)
{ int i,j=0,small,cur,time[2][30],k=0;
int *w =NULL;
w=(int*)malloc(sizeof(int)*n);
if(!w) return;
float s=0;
sort(jp,n,2);
for(i=0,small=0;i<n;i++)
  {w[i]=jp[i].burst;
   if(jp[i].priority >jp[small].priority)
    small=i; 
   }
cur=0;i=small;
while(chk(w,n))
  { time[0][k]=cur;
  for(j=cur+1,small=cur;j<n;j++)
   if(w[j]!=0)
    if(jp[j].arrival <= (s + w[cur]) && jp[j].priority < jp[cur].priority  )//check the smallest burst time 
{small=j;
break;
}
if(small==cur)
{ s+=w[cur];
w[cur]=0;
jp[cur].turnaround=s-jp[cur].arrival;
for(j=(cur+1)%n,small=i;j!=cur;j=(j+1)%n)
    if(w[j]!=0)
       if(jp[j].arrival<=s && jp[j].priority <=jp[small].priority)
        small=j;
    cur=small;  
}
else
{ s=s+jp[small].arrival-jp[cur].arrival;
w[cur]=w[cur]-jp[small].arrival + jp[cur].arrival;
cur=small;

}
time[1][k++]=s;
  }
  for(i=0;i<n;i++)
  jp[i].wait=jp[i].turnaround-jp[i].burst;
  free(w);
  display(jp,n);
  printf("\n\nGANTT CHART\n\t");


for(i=0;i<k;i++)
printf("--------");
   printf("\n\t|");
    for(i=0;i<k;i++)
     printf("%4s%4c",jp[time[0][i]].name,'|');
   printf("\n\t");
   for(i=0;i<k;i++)
printf("--------");
   printf("\n\t0");
   for(i=0;i<k;i++)
if(time[1][i]>9)
 printf("      %d",time[1][i]);
else
 printf("       %d",time[1][i]);
}
int main()
{ int ch,n,i;
float min;
job * jp=NULL;
job* cp=NULL;
printf("\n\nEnter the number of processes:");
scanf("%d",&n);
jp=(job*)malloc(sizeof(job)*n);
if(jp)
readprocess(jp,n);
do
{printf("\n\nCPU SCHEDULING ALGORITHMS\n1.PRIORITY- NONPREEMPTIVE\n2. PRIORITY- PREEMPTIVE \n3.ROUND-ROBIN\n4.EXIT\nEnter your choice:");
scanf("%d",&ch);
if(ch==3)
{
printf("\nEnter the duration of each time slot:");
scanf("%f",&min);
 printf("\n\nROUND-ROBIN SCHEDULING\n");
roundrobin(jp,n,min);
}
else  if(ch==1)
{
printf("\n\nPRIORITY NON-PREEMPTIVE SCHEDULING\n");
nonpreempt(jp,n);
}
else if(ch==2)
{
printf("\n\nPRIORITY-PREEMPTIVE SCHEDULING\n");
preempt(jp,n);
}
else if(ch==4)
printf("\nEXIT!!");
else 
printf("\nInvalid choice!!!");
}while(ch!=3);
}