//…….PROGRAM FOR SIMULATION OF FCFS CHEDULING ALGORITHM………..

//

#include<stdio.h>
main()
{
float avgwt,avgtt;
char pname[10][10],c[10][10];
int wt[10],tt[10],bt[10],at[10],t,q,i,n,sum=0,sbt=0,ttime,j,ss=0;
printf("\n\n Enter the number of processes: ");
scanf("%d",&n);
printf("\n\n Enter the NAME , BURST TIME and ARRIVAL TIME of the process");
for(i=0;i<n;i++)
{
printf("\n\n NAME : ");
scanf("%s",&pname[i]);
printf("\n\n BURST TIME : ");
scanf("%d",&bt[i]);
printf("\n\n ARRIVAL TIME : ");
scanf("%d",&at[i]);
}
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
{
if(at[i]>at[j])
{
t=at[i];
at[i]=at[j];
at[j]=t;
q=bt[i];
bt[i]=bt[j];
bt[j]=q;
strcpy(c[i],pname[i]);
strcpy(pname[i],pname[j]);
 strcpy(pname[j],c[i]);
}
}
wt[0]=0;
for(i=0;i<n;i++)
{
wt[i+1]=wt[i]+bt[i];
sum=sum+(wt[i]-at[i]);
sbt=sbt+(wt[i+1]-at[i]);
tt[i]=wt[i]+bt[i];
ss=ss+bt[i];
}
avgwt=(float) sum/n;
avgtt=(float)sbt/n;
printf("\n\n Average waiting time = %f",avgwt);
printf("\n\n Average turn-around time = %f",avgtt);
printf("\n\n GANTT CHART\n");
for(i=0;i<n;i++)
printf("|\t%s\t",pname[i]);
printf("\n");
for(i=0;i<n;i++)
printf("%d\t\t",wt[i]);
printf("%d\n",ss);
printf("\n");
}
OUTPUT:
[root@localhost ~]# ./a.out

Enter the number of processes: 4

Enter the NAME , BURST TIME and ARRIVAL TIME of the process

NAME : p1
BURST TIME : 4
ARRIVAL TIME : 0

NAME : p2
BURST TIME : 9
ARRIVAL TIME : 2

NAME : p3
BURST TIME : 8
ARRIVAL TIME : 4

NAME : p4
BURST TIME : 3
ARRIVAL TIME : 3

Average waiting time = 6.000000

Average turn-around time = 12.000000

GANTT CHART

| p1 | p2 | p4 | p3
0 4 13 16 24
 //……PROGRAM FOR SIMULATION OF SJF SCHEDULING ALGORITHM….//

#include<stdio.h>
main()
{
float avgwt,avgtt;
char pname[10][10],c[10][10];
int wt[10],tt[10],bt[10],at[10],t,q,i,n,sum=0,sbt=0,ttime,j,ss=0;
printf("\n\n Enter the number of processes: ");
scanf("%d",&n);
printf("\n\n Enter the NAME, BURSTTIME, and ARRIVALTIME of the processes ");
for(i=0;i<n;i++)
{
printf("\n\n NAME : ");
scanf("%s",&pname[i]);
printf("\n\n BURST TIME : ");
scanf("%d",&bt[i]);
printf("\n\n ARRIVAL TIME : ");
scanf("%d",&at[i]);
}
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
{
if(at[i]==at[j])
if(bt[i]>bt[j])
{
t=at[i];
at[i]=at[j];
at[j]=t;
q=bt[i];
bt[i]=bt[j];
bt[j]=q;
strcpy(c[i],pname[i]);
strcpy(pname[i],pname[j]);
 strcpy(pname[j],c[i]);
}
if(at[i]!=at[j])
if(bt[i]>bt[j])
{
t=at[i];
at[i]=at[j];
at[j]=t;
q=bt[i];
bt[i]=bt[j];
bt[j]=q;
strcpy(c[i],pname[i]);
strcpy(pname[i],pname[j]);
strcpy(pname[j],c[i]);
}
}
wt[0]=0;
for(i=0;i<n;i++)
{
wt[i+1]=wt[i]+bt[i];
sum=sum+(wt[i]-at[i]);
sbt=sbt+(wt[i+1]-at[i]);
tt[i]=wt[i]+bt[i];
ss=ss+bt[i];
}
printf("\n\n GANTT CHART");
printf("\n\n ---------------------------------------------------------------------- \n");
for(i=0;i<n;i++)
printf("|\t%s\t",pname[i]);
printf("\n-----------------------------------------------------------------------\n");
for(i=0;i<n;i++)
printf("%d\t\t",wt[i]);
printf("%d\n",ss);
printf("\n--------------------------------------------------------------------------");
printf("\n\n Total WAITING TIME = %d ",sum);
printf("\n\n Total TURNAROUND TIME = %d ",sbt);
avgwt=(float)sum/n;
avgtt=(float)sbt/n;
printf("\n\n Average WAITING TIME = %f ",avgwt);
printf("\n\n Average TURNAROUND TIME = %f ",avgtt);
}
OUTPUT:

Enter the number of processes: 5

Enter the NAME, BURSTTIME, and ARRIVALTIME of the processes

NAME : p0
BURST TIME : 2
ARRIVAL TIME : 0

NAME : p1
BURST TIME : 4
ARRIVAL TIME : 0

NAME : p2
BURST TIME : 5
ARRIVAL TIME : 0

NAME : p3
BURST TIME : 6
ARRIVAL TIME : 0

NAME : p4
BURST TIME : 8
ARRIVAL TIME : 0

GANTT CHART

----------------------------------------------------------------------
| p0 | p1 | p2 | p3 | p4
-----------------------------------------------------------------------
0 2 6 11 17 25

Total WAITING TIME = 36

Total TURNAROUND TIME = 61
Average WAITING TIME = 7.200000
//………PROGRAM FOR SIMULATION OF RR SCHEDULING ALGORITHM………//

#include<stdio.h>
main()
{
int pt[10][10],a[10][10],at[10],pname[10][10],i,j,n,k=0,q,sum=0;
float avg;
printf("\n\n Enter the number of processes : ");
scanf("%d",&n);
for(i=0;i<10;i++)
{
for(j=0;j<10;j++)
{
pt[i][j]=0;
a[i][j]=0;
}
}
for(i=0;i<n;i++)
{
j=0;
printf("\n\n Enter the process time for process %d : ",i+1);
scanf("%d",&pt[i][j]);
}
printf("\n\n Enter the time slice : ");
scanf("%d",&q);
printf("\n\n");
for(j=0;j<10;j++)
{
for(i=0;i<n;i++)
{
a[2*j][i]=k;
if((pt[i][j]<=q)&&(pt[i][j]!=0))
{
 pt[i][j+1]=0;
printf(" %d P%d %d\n",k,i+1,k+pt[i][j]);
k+=pt[i][j];
a[2*j+1][i]=k;
}
else if(pt[i][j]!=0)
{
pt[i][j+1]=pt[i][j]-q;
printf(" %d P%d %d\n",k,i+1,(k+q));
k+=q;
a[2*j+1][i]=k;
}
else
{
a[2*j][i]=0;
a[2*j+1][i]=0;
}
}
}
for(i=0;i<n;i++)
sum+=a[0][i];
for(i=0;i<n;i++)
{
for(j=1;j<10;j++)
{
if((a[j][i]!=0)&&(a[j+1][i]!=0)&&((j+1)%2==0))
sum+=((a[j+1][i]-a[j][i]));
}
}
avg=(float)sum/n;
printf("\n\n Average waiting time = %f msec",avg);
sum=avg=0;
for(j=0;j<n;j++)
{
i=1;
while(a[i][j]!=0)
i+=1;
sum+=a[i-1][j];
}
avg=(float)sum/n;
printf("\n\n Average turnaround time = %f msec\n\n",avg);
}

OUTPUT:

[root@localhost ~]# ./a.out

Enter the number of processes : 4

Enter the process time for process 1 : 8

Enter the process time for process 2 : 3
Enter the process time for process 3 : 6
Enter the process time for process 4 : 1

Enter the time slice : 2

0 P1 2
2 P2 4
4 P3 6
6 P4 7
7 P1 9
9 P2 10
10 P3 12
12 P1 14
14 P3 16
16 P1 18

Average waiting time = 8.250000 msec

Average turnaround time = 12.750000 msec
 //…PROGRAM FOR SIMULATION OF PRIORITY SCHEDULING ALGORITHM…//

#include<stdio.h>
main()
{
float avgwt,avgtt;
char pname[10][10],c[10][10];
int wt[10],tt[10],bt[10],pt[10],t,q,i,n,sum=0,sbt=0,ttime,j,ss=10;
printf("\n\n Enter the number of processes : ");
scanf("%d",&n);
printf("\n\n Enter the NAME and BURSTTIME ");
for(i=0;i<n;i++)
{
printf("\n\n NAME : ");
scanf("%s",&pname[i]);
printf("\n\n BURSTTIME : ");
scanf("%d",&bt[i]);
}
printf("\n\n Enter the priorities of the processes ");
for(i=0;i<n;i++)
{
printf("\n\n Priority of process%d : ",i+1);
scanf("%d",&pt[i]);
}
for(i=0;i<n;i++)
for(j=i+1;j<n;j++)
{
if(pt[i]>pt[j])
{
t=pt[i];
pt[i]=pt[j];
pt[j]=t;
q=bt[i];
 bt[i]=bt[j];
bt[j]=q;
strcpy(c[i],pname[i]);
strcpy(pname[i],pname[j]);
strcpy(pname[j],c[i]);
}
}
wt[0]=0;
for(i=0;i<n;i++)
{
wt[i+1]=wt[i]+bt[i];
sum=sum+wt[i];
sbt=sbt+wt[i+1];
tt[i]=wt[i]+bt[i];
ss=ss+bt[i];
}
printf("\n\n GANTT CHART");
printf("\n-----------------------------------------------------------------\n");
for(i=0;i<n;i++)
printf("|\t%s\t",pname[i]);
printf("\n-----------------------------------------------------------------\n");
for(i=0;i<n;i++)
printf("%d\t\t",wt[i]);
printf("%d\n",ss);
printf("\n-----------------------------------------------------------------\n");
printf("\n\n Total WAITING TIME of the process = %d",sum);
printf("\n\n Total TURNAROUND TIME of the process = %d",sbt);
avgwt=(float)sum/n;
avgtt=(float)sbt/n;
printf("\n\n Average WAITING TIME of the process = %f",avgwt);
printf("\n\n Average TURNAROUND TIME of the process = %f",avgtt);
}
OUTPUT:
[root@localhost ~]# ./a.out
Enter the number of processes : 4
Enter the NAME and BURSTTIME

NAME : p1
BURSTTIME : 8

NAME : p2
BURSTTIME : 3

NAME : p3
BURSTTIME : 6

NAME : p4
BURSTTIME : 1

Enter the priorities of the processes

Priority of process1 : 1
Priority of process2 : 5
Priority of process3 : 2
Priority of process4 : 4

GANTT CHART
------------------------------------------------------
| p1 | p3 | p4 | p2
------------------------------------------------------
0 8 14 15 28

Total WAITING TIME of the process = 37

Total TURNAROUND TIME of the process = 55
Average WAITING TIME of the process = 9.250000
Average TURNAROUND TIME of the process = 13.750000
 //……PROGRAM FOR INTER-PROCESS COMMUNICATION USING PIPES……//

#include<stdio.h>
#include<unistd.h>
#include<sys/ipc.h>
#include<sys/uio.h>
#include<sys/types.h>
main()
{
int pid,pfd[2],n,a,b,c;
if(pipe(pfd)==-1)
{
printf("\nError in pipe connection\n");
exit(1);
}
pid=fork();
if(pid>0)
{
printf("\nParent Process");\
printf("\n\n\tFibonacci Series");
printf("\nEnter the limit for the series:");
scanf("%d",&n);
close(pfd[0]);
write(pfd[1],&n,sizeof(n));
close(pfd[1]);
exit(0);
}
else
{
close(pfd[1]);
read(pfd[0],&n,sizeof(n));
printf("\nChild Process");
a=0;
 b=1;
close(pfd[0]);
printf("\nFibonacci Series is:");
printf("\n\n%d\n%d",a,b);
while(n>2)
{
c=a+b;
printf("\n%d",c);
a=b;
b=c;
n--;
}
}
}

OUTPUT:
[root@localhost ~]# ./a.out
Parent Process
Fibonacci Series
Enter the limit for the series:5

Child Process
Fibonacci Series is:
0
1
1
2
3
 //……….PROGRAM FOR PRODUCER CONSUMER PROBLEM ……….//

#include<stdio.h>
int mutex=1,full=0,empty=3,x=0;
main()
{
int n;
void producer();
void consumer();
int wait(int);
int signal(int);
printf("\n1.PRODUCER\n2.CONSUMER\n3.EXIT\n");
while(1)
{
printf("\nENTER YOUR CHOICE\n");
scanf("%d",&n);
switch(n)
{
case 1:
if((mutex==1)&&(empty!=0))
producer();
else
printf("BUFFER IS FULL");
break;
case 2:
if((mutex==1)&&(full!=0))
consumer();
else
printf("BUFFER IS EMPTY");
break;
case 3:
exit(0);
break;
 }
}
}
int wait(int s)
{
return(--s);
}
int signal(int s)
{
return(++s);
}
void producer()
{
mutex=wait(mutex);
full=signal(full);
empty=wait(empty);
x++;
printf("\nproducer produces the item%d",x);
mutex=signal(mutex);
}
void consumer()
{
mutex=wait(mutex);
full=wait(full);
empty=signal(empty);
printf("\n consumer consumes item%d",x);
x--;
mutex=signal(mutex);
}
OUTPUT:

[root@localhost ~]# ./a.out

1.PRODUCER

2.CONSUMER

3.EXIT

ENTER YOUR CHOICE

1
producer produces the item1

ENTER YOUR CHOICE

1
producer produces the item2

ENTER YOUR CHOICE

2
consumer consumes item2

ENTER YOUR CHOICE

2
consumer consumes item1

ENTER YOUR CHOICE

2
BUFFER IS EMPTY

ENTER YOUR CHOICE

3
 //……PROGRAM FOR DIRECTORIES MANAGEMENTS……//

#include<sys/types.h>
#include<dirent.h>
#include<stdio.h>
main(int c,char* arg[])
{
DIR *d;
struct dirent *r;
int i=0;
d=opendir(arg[1]);
printf("\n\t NAME OF ITEM \n");
while((r=readdir(d)) != NULL)
{
printf("\t %s \n",r->d_name);
i=i+1;
}
printf("\n TOTAL NUMBER OF ITEM IN THAT DIRECTORY IS %d \n",i);
}
OUTPUT:

[root@localhost ~]# cc dr.c

[root@localhost ~]# ./a.out lab_print

NAME OF ITEM
pri_output.doc
sjf_output.doc
fcfs_output.doc
rr_output.doc
.
..
ipc_pipe_output.doc
pro_con_prob_output.doc

TOTAL NUMBER OF ITEM IN THAT DIRECTORY IS 8

 //……PROGRAM FOR I/O SYSTEM CALLS……//

#include<stdio.h>
#include<sys/stat.h>
#include<time.h>
main(int ag,char*arg[])
{
char buf[100];
struct stat s;
int fd1,fd2,n;
fd1=open(arg[1],0);
fd2=creat(arg[2],0777);
stat(arg[2],&s);
if(fd2==-1)
printf("ERROR IN CREATION");
while((n=read(fd1,buf,sizeof(buf)))>0)
{
if(write(fd2,buf,n)!=n)
{
close(fd1);
close(fd2);
}
}
printf("\t\n UID FOR FILE.......>%d \n FILE ACCESS TIME.....>%s \n FILE
MODIFIED TIME........>%s \n FILE I-NODE NUMBER......>%d \n PERMISSION FOR
FILE.....>%o\n\n",s.st_uid,ctime(&s.st_atime),ctime(&s.st_mtime),s.st_mode);
close(fd1);
close(fd2);
}
OUTPUT:
[root@localhost ~]# cc iosys.c
[root@localhost ~]# ./a.out

UID FOR FILE.......>0

FILE ACCESS TIME.....>Thu Apr 8 01:23:54 2010

FILE MODIFIED TIME........>Thu Apr 8 01:23:54 2010

FILE I-NODE NUMBER......>33261

PERMISSION FOR FILE.....>1001101014
 //…PROGRAM FOR UNIX COMMAND SIMULATION (GREP)…//

#include<stdio.h>
#include<string.h>
main(int ag,char* arg[])
{
char buf[200],line[200];
int i,j,n,fd1,count=0,opt;
if(ag==4)
{
fd1=open(arg[3],0);
if(strcmp(arg[1],"-c")==0) opt=2;
if(strcmp(arg[1],"-i")==0) opt=3;
}
else if(ag==3)
{
fd1=open(arg[2],0);
opt=1;
}
if(fd1==-1) printf("error in opening");
j=0;
switch(opt)
{
case 1:
while((n=read(fd1,buf,sizeof(line)))>0)
{
for(i=0;i<n;i++,j++)
{
if(buf[i]!='\n') line[j]=buf[i];
else
{
line[j]='\n';
if(strstr(line,arg[1])!=0)
 write(1,line,j+1);
}
}
}
break;

case 2:
while((n=read(fd1,buf,sizeof(line)))>0)
{
for(i=0;i<n;i++,j++)
{
if(buf[i]!='\n') line[j]=buf[i];
else
{
line[j]='\n';
if(strstr(line,arg[2])!=0)
count=count+1;
j=-1;
}
}
}
printf("%d \n",count);
break;
case 3:
while((n=read(fd1,buf,sizeof(line)))>0)
{
for(i=0;i<n;i++,j++)
{
if(buf[i]!='\n') line[j]=buf[i];
else
{
line[j]='\n';
if(strcasestr(line,arg[2])!=0)
 write(1,line,j+1);
j=-1;
}
}
}
break;
}
close(fd1);
}

OUTPUT:
[root@localhost ~]# cat tst
sd
d
s
a
A
S
D

[root@localhost ~]# ./a.out -i a tst

a
A
[root@localhost ~]# ./a.out -c a tst
1
[root@localhost ~]# ./a.out -c A tst
1
[root@localhost ~]# ./a.out -c sd tst
1
[root@localhost ~]# ./a.out -c s tst
2
 //……PROGRAM FOR PROCESS MANAGEMENTS……//

#include<stdio.h>
main(int arc,char*ar[])
{
int pid;
char s[100];
pid=fork();
if(pid<0)
printf("error");
else if(pid>0)
{
wait(NULL);
printf("\n Parent Process:\n");
printf("\n\tParent Process id:%d\t\n",getpid());
execlp("cat","cat",ar[1],(char*)0);
error("can’t execute cat %s,",ar[1]);
}
else
{
printf("\nChild process:");
printf("\n\tChildprocess parent id:\t %d",getppid());
sprintf(s,"\n\tChild process id :\t%d",getpid());
write(1,s,strlen(s));
printf(" ");
printf(" ");
printf(" ");
execvp(ar[2],&ar[2]);
error("can’t execute %s",ar[2]);
}
}
OUTPUT:

[root@localhost ~]# ./a.out tst date

Child process:

Child process id : 3137 Sat Apr 10 02:45:32 IST 2010

Parent Process:

Parent Process id:3136

sd
d
s
a
A
S
D

[root@localhost ~]# cat tst

sd
d
s
a
A
S
D
 //……PROGRAM FOR FIRST FIT…...//
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
struct allocate
{
int pid;
int st_add;
int end_add;
struct allocate *next;
};

struct free_list
{
int st_add;
int end_add;
struct free_list *next;
};

struct process
{
int pid;
int size;
};

struct process pro[10];

struct free_list *flist=NULL;
struct allocate *alot=NULL;

void display_alot(struct allocate *temp_a)

{
printf("\n\n allocated list:");
printf("\n================");
while(temp_a!=NULL)
{
printf("\n process:%d st_add:%d end_add:%d ",temp_a->pid,temp_a->st_add,temp_a-
>end_add);
temp_a=temp_a->next;
}
}

void display_free(struct free_list *temp_f)

{
printf("\n\n free list:");
printf("\n=================");
while(temp_f!=NULL)
{
printf("\n st_add:%d end_add:%d",temp_f->st_add,temp_f->end_add);
temp_f=temp_f->next;
}
}

void insert(int p)
{
struct free_list *temp_f;
struct allocate *temp_a,*pre_a;
int i,n;
do
{
srand((unsigned int)time((time_t*)NULL));
n=rand()%5;
}while(n==0);
printf("\n\n no. of process:%d",n);
for(i=0;i<n;i++)
{
pro[i].pid=i+p;
do
{
pro[i].size=rand()%300;
}while(pro[i].size==0);
}
for(i=0;i<n;i++)
{
printf("\n\n process to be inserted:%d size:%d",pro[i].pid,pro[i].size);
temp_f=flist;
temp_a=alot;
while(temp_f!=NULL && temp_f->end_add-temp_f->st_add < pro[i].size)
{
temp_f=temp_f->next;
}
if(temp_f!=NULL)
{
pre_a=(struct allocate*)malloc(sizeof(struct allocate));
pre_a->st_add=temp_f->st_add;
pre_a->end_add=temp_f->st_add=temp_f->st_add+pro[i].size;
pre_a->pid=pro[i].pid;
if(temp_a==NULL)
{
alot=pre_a;
pre_a->next=NULL;
}
else
{
while(temp_a->next!=NULL)
{
temp_a=temp_a->next;
}
temp_a->next=pre_a;
pre_a->next=NULL;
}
}
else
printf("\n there is not enough space");
display_alot(alot);
display_free(flist);
getch();
}
}

void main()
{
int no,n,i,nod,ndpid;
struct process pro[10];
struct free_list *temp_f,*free_alot,*pre_f;
struct allocate *temp_a,*pre_a;
clrscr();
alot=NULL;
flist=(struct free_list*)malloc(sizeof(struct free_list));
flist->st_add=0;
flist->end_add=1024;
flist->next=NULL;
insert(0);
do
{
srand((unsigned int)time((time_t*)NULL));
nod=rand()%2;
}while(nod==0);
printf("\n\n no.of process deletion:%d",nod);
for(i=0;i<nod;i++)
{
printf("\n\n\n process to be deleted:");
scanf("%d",&ndpid);
temp_a=alot;
temp_f=flist;
while(temp_a!=NULL && temp_a->pid!=ndpid)
{
pre_a=temp_a;
temp_a=temp_a->next;
}
if(temp_a!=NULL)
{
if(alot==temp_a)
alot=temp_a->next;
else
pre_a->next=temp_a->next;
pre_f=NULL;
while(temp_f!=NULL && temp_f->st_add < temp_a->st_add)
{
pre_f=temp_f;
temp_f=temp_f->next;
}
if(pre_f!=NULL && pre_f->end_add==temp_a->st_add)
pre_f->end_add=temp_a->end_add;
else if(pre_f!=NULL&&temp_f!=NULL&&temp_f->st_add==temp_a->end_add)
temp_f->st_add=temp_a->st_add;
else
{
free_alot=(struct free_list*)malloc(sizeof(struct free_list));
free_alot->st_add=temp_a->st_add;
free_alot->end_add=temp_a->end_add;
if(pre_f!=NULL)
pre_f->next=free_alot;
free_alot->next=temp_f;
if(flist==temp_f)
{
flist=free_alot;
}
}
free(temp_a);
}
else printf("\n process not in memory");
temp_f=flist;
while(temp_f!=NULL)
{
if(temp_f->end_add==temp_f->next->st_add)
{
temp_f->end_add=temp_f->next->end_add;
temp_f->next=temp_f->next->next;
}
temp_f=temp_f->next;
}
display_alot(alot);
display_free(flist);
getch();
}
insert(10);
}
OUTPUT: st_add:551 end_add:1024

no. of process:3 no. of process:3

process to be inserted:0 size:120
process to be inserted:10 size:195
allocated list:
================ allocated list:
process:0 st_add:0 end_add:120 ================
process:1 st_add:120 end_add:305
free list: process:2 st_add:305 end_add:551
================= process:10 st_add:551 end_add:746
st_add:120 end_add:1024
process to be inserted:1 size:185 free list:
=================
allocated list: st_add:0 end_add:120
================ st_add:746 end_add:1024
process:0 st_add:0 end_add:120
process:1 st_add:120 end_add:305 process to be inserted:11 size:96

free list: allocated list:

================= ================
st_add:305 end_add:1024 process:1 st_add:120 end_add:305
process:2 st_add:305 end_add:551
process to be inserted:2 size:246 process:10 st_add:551 end_add:746
process:11 st_add:0 end_add:96
allocated list:
================ free list:
process:0 st_add:0 end_add:120 =================
process:1 st_add:120 end_add:305 st_add:96 end_add:120
process:2 st_add:305 end_add:551 st_add:746 end_add:1024

free list: process to be inserted:12 size:148

=================
st_add:551 end_add:1024 allocated list:
================
no.of process deletion:1 process:1 st_add:120 end_add:305
process to be deleted:0 process:2 st_add:305 end_add:551
process:10 st_add:551 end_add:746
allocated list: process:11 st_add:0 end_add:96
================ process:12 st_add:746 end_add:894
process:1 st_add:120 end_add:305
process:2 st_add:305 end_add:551 free list:
=================
free list: st_add:96 end_add:120
================= st_add:894 end_add:1024
st_add:0 end_add:120
 //……PROGRAM FOR BEST FIT…...//
#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
struct allocate
{
int pid;
int st_add;
int end_add;
struct allocate *next;
};

struct free_list
{
int st_add;
int end_add;
struct free_list *next;
};

struct process
{
int pid;
int size;
};

struct process pro[10];

struct free_list *flist=NULL;
struct allocate *alot=NULL;

void display_alot(struct allocate *temp_a)

{
printf("\n\n allocated list:");
printf("\n================");
while(temp_a!=NULL)
{
printf("\n process:%d st_add:%d end_add:%d ",temp_a->pid,temp_a->st_add,temp_a-
>end_add);
temp_a=temp_a->next;
}
}

void display_free(struct free_list *temp_f)

{
printf("\n\n free list:");
printf("\n=================");
while(temp_f!=NULL)
{
printf("\n st_add:%d end_add:%d",temp_f->st_add,temp_f->end_add);
temp_f=temp_f->next;
}
}

void insert(int p)
{
struct free_list *temp_f;
struct allocate *temp_a,*pre_a;
int i,n;
do
{
srand((unsigned int)time((time_t*)NULL));
n=rand()%10;
}while(n==0);

printf("\n\n no. of process:%d",n);

for(i=0;i<n;i++)
{
pro[i].pid=i+p;
do
{
pro[i].size=rand()%550;
}while(pro[i].size==0);
}
for(i=0;i<n;i++)
{
printf("\n\n process to be inserted:%d size:%d",pro[i].pid,pro[i].size);
temp_f=flist;
temp_a=alot;
while(temp_f!=NULL && temp_f->end_add-temp_f->st_add < pro[i].size)
{
temp_f=temp_f->next;
}
if(temp_f!=NULL)
{
pre_a=(struct allocate*)malloc(sizeof(struct allocate));
pre_a->st_add=temp_f->st_add;
pre_a->end_add=temp_f->st_add=temp_f->st_add+pro[i].size;
pre_a->pid=pro[i].pid;
if(temp_a==NULL)
{
alot=pre_a;
pre_a->next=NULL;
}
else
{
while(temp_a->next!=NULL)
{
temp_a=temp_a->next;
}
temp_a->next=pre_a;
pre_a->next=NULL;
}
}
else
printf("\n there is not enough space");
display_alot(alot);
display_free(flist);
getch();
}
}

void bestfit(int p)
{
struct free_list *temp_f,*enough_hole;
struct allocate *temp_a,*pre_a;
int i,n,rem_space;
do
{
srand((unsigned int)time((time_t*)NULL));
n=rand()%10;
}while(n==0);
printf("\n no of processes:%d",n);
for(i=0;i<n;i++)
{
pro[i].pid=i+p;
do
{
pro[i].size=rand()%200;
}
while(pro[i].size==0);
}
for(i=0;i<n;i++)
{
printf("\n process to be inserted:%d size:%d",pro[i].pid,pro[i].size);
temp_f=flist;
temp_a=alot;
enough_hole=NULL;
rem_space=1024;
while(temp_f!=NULL)
{
if(temp_f->end_add - temp_f->st_add >= pro[i].size)
{
if(temp_f->end_add - temp_f->st_add - pro[i].size<rem_space)
{
rem_space=temp_f->end_add - temp_f->st_add - pro[i].size;
enough_hole=temp_f;
}
}
temp_f=temp_f->next;
}
if(enough_hole!=NULL)
{
pre_a=(struct allocate*)malloc(sizeof(struct allocate));
pre_a->st_add=enough_hole->st_add;
pre_a->end_add=enough_hole->st_add=enough_hole->st_add + pro[i].size;
pre_a->pid=pro[i].pid;
if(temp_a==NULL)
{
alot=pre_a;
pre_a->next=NULL;
}
else
{
while(temp_a->next!=NULL)
{
temp_a=temp_a->next;
}
temp_a->next=pre_a;
pre_a->next=NULL;
}
}
else
printf("\n there is not enough space");
display_alot(alot);
display_free(flist);
getch();
}
}

void main()
{
int no,n,i,nod,ndpid;
struct process pro[10];
struct free_list *temp_f,*free_alot,*pre_f;
struct allocate *temp_a,*pre_a;
clrscr();
alot=NULL;
flist=(struct free_list*)malloc(sizeof(struct free_list));
flist->st_add=0;
flist->end_add=1024;
flist->next=NULL;
insert(0);
do
{
srand((unsigned int)time((time_t*)NULL));
nod=rand()%5;
}while(nod==0);
printf("\n\n no.of process deletion:%d",nod);
for(i=0;i<nod;i++)
{
printf("\n\n\n process to be deleted:");
scanf("%d",&ndpid);
temp_a=alot;
temp_f=flist;
while(temp_a!=NULL && temp_a->pid!=ndpid)
{
pre_a=temp_a;
temp_a=temp_a->next;
}
if(temp_a!=NULL)
{
if(alot==temp_a)
alot=temp_a->next;
else
pre_a->next=temp_a->next;
pre_f=NULL;
while(temp_f!=NULL && temp_f->st_add < temp_a->st_add)
{
pre_f=temp_f;
temp_f=temp_f->next;
}
if(pre_f!=NULL && pre_f->end_add==temp_a->st_add)
pre_f->end_add=temp_a->end_add;
else if(pre_f!=NULL&&temp_f!=NULL&&temp_f->st_add==temp_a->end_add)
temp_f->st_add=temp_a->st_add;
else
{
free_alot=(struct free_list*)malloc(sizeof(struct free_list));
free_alot->st_add=temp_a->st_add;
free_alot->end_add=temp_a->end_add;
if(pre_f!=NULL)
pre_f->next=free_alot;
free_alot->next=temp_f;
if(flist==temp_f)
{
flist=free_alot;
}
}
free(temp_a);
}
else printf("\n process not in memory");
temp_f=flist;
while(temp_f!=NULL)
{
if(temp_f->end_add==temp_f->next->st_add)
{
temp_f->end_add=temp_f->next->end_add;
temp_f->next=temp_f->next->next;
}
temp_f=temp_f->next;
}
display_alot(alot);
display_free(flist);
getch();
}
bestfit(10);
}
OUTPUT:
process to be inserted:4 size:542
no. of process:7 there is not enough space

process to be inserted:0 size:351 allocated list:

================
allocated list: process:0 st_add:0 end_add:351
================ process:1 st_add:351 end_add:817
process:0 st_add:0 end_add:351
free list:
free list: =================
================= st_add:817 end_add:1024
st_add:351 end_add:1024
process to be inserted:5 size:547
process to be inserted:1 size:466 there is not enough space

allocated list: allocated list:

================ ================
process:0 st_add:0 end_add:351 process:0 st_add:0 end_add:351
process:1 st_add:351 end_add:817 process:1 st_add:351 end_add:817

free list: free list:

================= =================
st_add:817 end_add:1024 st_add:817 end_add:1024

process to be inserted:2 size:337 process to be inserted:6 size:89

there is not enough space
allocated list:
allocated list: ================
================ process:0 st_add:0 end_add:351
process:0 st_add:0 end_add:351 process:1 st_add:351 end_add:817
process:1 st_add:351 end_add:817 process:6 st_add:817 end_add:906

free list: free list:

================= =================
st_add:817 end_add:1024 st_add:906 end_add:1024

process to be inserted:3 size:410 no.of process deletion:4

there is not enough space
process to be deleted:0
allocated list:
================ allocated list:
process:0 st_add:0 end_add:351 ================
process:1 st_add:351 end_add:817 process:1 st_add:351 end_add:817
process:6 st_add:817 end_add:906
free list:
================= free list:
st_add:817 end_add:1024 =================
st_add:0 end_add:351 process:6 st_add:817 end_add:906
st_add:906 end_add:1024 process:10 st_add:0 end_add:155

process to be deleted:2 free list:

process not in memory =================
st_add:155 end_add:351
allocated list: st_add:906 end_add:1024
================
process:1 st_add:351 end_add:817 process to be inserted:11 size:43
process:6 st_add:817 end_add:906
allocated list:
free list: ================
================= process:1 st_add:351 end_add:817
st_add:0 end_add:351 process:6 st_add:817 end_add:906
st_add:906 end_add:1024 process:10 st_add:0 end_add:155

process:11 st_add:906 end_add:949

process to be deleted:3
process not in memory free list:
=================
allocated list: st_add:155 end_add:351
================ st_add:949 end_add:1024
process:1 st_add:351 end_add:817
process:6 st_add:817 end_add:906 process to be inserted:12 size:188

free list: allocated list:

================= ================
st_add:0 end_add:351 process:1 st_add:351 end_add:817
st_add:906 end_add:1024 process:6 st_add:817 end_add:906
process:10 st_add:0 end_add:155
process to be deleted:4 process:11 st_add:906 end_add:949
process not in memory process:12 st_add:155 end_add:343

allocated list: free list:

================ =================
process:1 st_add:351 end_add:817 st_add:343 end_add:351
process:6 st_add:817 end_add:906 st_add:949 end_add:1024

free list: process to be inserted:13 size:7

=================
st_add:0 end_add:351 allocated list:
st_add:906 end_add:1024 ================
process:1 st_add:351 end_add:817
no of processes:9 process:6 st_add:817 end_add:906
process to be inserted:10 size:155 process:10 st_add:0 end_add:155
process:11 st_add:906 end_add:949
allocated list: process:12 st_add:155 end_add:343
================ process:13 st_add:343 end_add:350
process:1 st_add:351 end_add:817
free list: process:10 st_add:0 end_add:155
================= process:11 st_add:906 end_add:949
st_add:350 end_add:351 process:12 st_add:155 end_add:343
st_add:949 end_add:1024 process:13 st_add:343 end_add:350

process to be inserted:14 size:160 free list:

there is not enough space =================
st_add:350 end_add:351
allocated list: st_add:949 end_add:1024
================
process:1 st_add:351 end_add:817 process to be inserted:17 size:51
process:6 st_add:817 end_add:906
process:10 st_add:0 end_add:155 allocated list:
process:11 st_add:906 end_add:949 ================
process:12 st_add:155 end_add:343 process:1 st_add:351 end_add:817
process:13 st_add:343 end_add:350 process:6 st_add:817 end_add:906
process:10 st_add:0 end_add:155
free list: process:11 st_add:906 end_add:949
================= process:12 st_add:155 end_add:343
st_add:350 end_add:351 process:13 st_add:343 end_add:350
st_add:949 end_add:1024 process:17 st_add:949 end_add:1000
process to be inserted:15 size:100
there is not enough space free list:
=================
allocated list: st_add:350 end_add:351
================ st_add:1000 end_add:1024
process:1 st_add:351 end_add:817
process:6 st_add:817 end_add:906 process to be inserted:18 size:42
process:10 st_add:0 end_add:155 there is not enough space
process:11 st_add:906 end_add:949
process:12 st_add:155 end_add:343 allocated list:
process:13 st_add:343 end_add:350 ================
process:1 st_add:351 end_add:817
free list: process:6 st_add:817 end_add:906
================= process:10 st_add:0 end_add:155
st_add:350 end_add:351 process:11 st_add:906 end_add:949
st_add:949 end_add:1024 process:12 st_add:155 end_add:343
process:13 st_add:343 end_add:350
process to be inserted:16 size:198 process:17 st_add:949 end_add:1000
there is not enough space
free list:
allocated list: =================
================ st_add:350 end_add:351
process:1 st_add:351 end_add:817 st_add:1000 end_add:1024
process:6 st_add:817 end_add:906
 //……PROGRAM FOR WORST FIT…...//

#include<conio.h>
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
struct allocate
{ int pid; int st_add; int end_add; struct allocate *next; };

struct free_list
{ int st_add; int end_add; struct free_list *next; };

struct process
{ int pid; int size; };

struct process pro[10];

struct free_list *flist=NULL;
struct allocate *alot=NULL;

void display_alot(struct allocate *temp_a)

{
printf("\n\n allocated list:");
printf("\n================");
while(temp_a!=NULL)
{
printf("\n process:%d st_add:%d end_add:%d ",temp_a->pid,temp_a->st_add,temp_a-
>end_add);
temp_a=temp_a->next;
}
}

void display_free(struct free_list *temp_f)

{
printf("\n\n free list:");
printf("\n=================");
while(temp_f!=NULL)
{
printf("\n st_add:%d end_add:%d",temp_f->st_add,temp_f->end_add);
temp_f=temp_f->next;
}
}

void insert(int p)
{
struct free_list *temp_f;
struct allocate *temp_a,*pre_a;
int i,n;
do
{
srand((unsigned int)time((time_t*)NULL));
n=rand()%10;
}while(n==0);

printf("\n\n no. of process:%d",n);

for(i=0;i<n;i++)
{
pro[i].pid=i+p;
do
{
pro[i].size=rand()%550;
}while(pro[i].size==0);
}
for(i=0;i<n;i++)
{
printf("\n\n process to be inserted:%d size:%d",pro[i].pid,pro[i].size);
temp_f=flist;
temp_a=alot;
while(temp_f!=NULL && temp_f->end_add-temp_f->st_add < pro[i].size)
{
temp_f=temp_f->next;
}
if(temp_f!=NULL)
{
pre_a=(struct allocate*)malloc(sizeof(struct allocate));
pre_a->st_add=temp_f->st_add;
pre_a->end_add=temp_f->st_add=temp_f->st_add+pro[i].size;
pre_a->pid=pro[i].pid;
if(temp_a==NULL)
{
alot=pre_a;
pre_a->next=NULL;
}
else
{
while(temp_a->next!=NULL)
{
temp_a=temp_a->next;
}
temp_a->next=pre_a;
pre_a->next=NULL;
}
}
else
printf("\n there is not enough space");
display_alot(alot);
display_free(flist);
getch();
}
}
void worstfit(int p)
{
struct free_list *temp_f,*big_hole;
struct allocate *temp_a,*pre_a;
int i,n;
do
{
srand((unsigned int)time((time_t*)NULL));
n=rand()%10;
}while(n==0);
printf("\n no.of process:%d",n);
for(i=0;i<n;i++)
{
pro[i].pid=i+p;
do
{
pro[i].size=rand()%250;
}
while(pro[i].size==0);
}
for(i=0;i<n;i++)
{
printf("\n process to be inserted: %d size :%d",pro[i].pid,pro[i].size);
temp_f=flist;
temp_a=alot;
big_hole=NULL;
while(temp_f!=NULL)
{
if(temp_f->end_add-temp_f->st_add>=pro[i].size)
{
if(big_hole==NULL)
big_hole=temp_f;
else if(temp_f->end_add - temp_f->st_add > big_hole-> end_add - big_hole-> st_add)
big_hole=temp_f;
}
temp_f=temp_f->next;
}
if(big_hole!= NULL)
{
pre_a=(struct allocate*) malloc (sizeof(struct allocate));
pre_a->st_add=big_hole->st_add;
pre_a->end_add=big_hole->st_add=big_hole->st_add + pro[i].size;
pre_a->pid=pro[i].pid;
if(temp_a==NULL)
{
alot=pre_a;
pre_a->next=NULL;
}
else
{
while(temp_a->next!=NULL)
temp_a=temp_a->next;
temp_a->next= pre_a;
pre_a->next=NULL;
}
}
else
printf("\n there is not enough space");
display_alot(alot);
display_free(flist);
getch();
}
}

void main()
{
int no,n,i,nod,ndpid;
struct process pro[10];
struct free_list *temp_f,*free_alot,*pre_f;
struct allocate *temp_a,*pre_a;
clrscr();
alot=NULL;
flist=(struct free_list*)malloc(sizeof(struct free_list));
flist->st_add=0;
flist->end_add=1024;
flist->next=NULL;
insert(0);
do
{
srand((unsigned int)time((time_t*)NULL));
nod=rand()%5;
}while(nod==0);
printf("\n\n no.of process deletion:%d",nod);
for(i=0;i<nod;i++)
{
printf("\n\n\n process to be deleted:");
scanf("%d",&ndpid);
temp_a=alot;
temp_f=flist;
while(temp_a!=NULL && temp_a->pid!=ndpid)
{
pre_a=temp_a;
temp_a=temp_a->next;
}
if(temp_a!=NULL)
{
if(alot==temp_a)
alot=temp_a->next;
else
pre_a->next=temp_a->next;
pre_f=NULL;
while(temp_f!=NULL && temp_f->st_add < temp_a->st_add)
{
pre_f=temp_f;
temp_f=temp_f->next;
}
if(pre_f!=NULL && pre_f->end_add==temp_a->st_add)
pre_f->end_add=temp_a->end_add;
else if(pre_f!=NULL&&temp_f!=NULL&&temp_f->st_add==temp_a->end_add)
temp_f->st_add=temp_a->st_add;
else
{
free_alot=(struct free_list*)malloc(sizeof(struct free_list));
free_alot->st_add=temp_a->st_add;
free_alot->end_add=temp_a->end_add;
if(pre_f!=NULL)
pre_f->next=free_alot;
free_alot->next=temp_f;
if(flist==temp_f)
{
flist=free_alot;
}
}
free(temp_a);
}
else printf("\n process not in memory");
temp_f=flist;
while(temp_f!=NULL)
{
if(temp_f->end_add==temp_f->next->st_add)
{
temp_f->end_add=temp_f->next->end_add;
temp_f->next=temp_f->next->next;
}
temp_f=temp_f->next;
}
display_alot(alot);
display_free(flist);
getch();
}
worstfit(10);
}
OUTPUT: free list:
=================
no. of process:9
st_add:594 end_add:1024
process to be inserted:0 size:21
process to be inserted:4 size:182
allocated list:
allocated list:
================
================
process:0 st_add:0 end_add:21
process:0 st_add:0 end_add:21
process:1 st_add:21 end_add:490
free list:
process:2 st_add:490 end_add:520
=================
process:3 st_add:520 end_add:594
st_add:21 end_add:1024
process:4 st_add:594 end_add:776
process to be inserted:1 size:469
free list:
=================
allocated list:
st_add:776 end_add:1024
================
process:0 st_add:0 end_add:21
process to be inserted:5 size:100
process:1 st_add:21 end_add:490
allocated list:
free list:
================
=================
process:0 st_add:0 end_add:21
st_add:490 end_add:1024
process:1 st_add:21 end_add:490
process:2 st_add:490 end_add:520
process to be inserted:2 size:30
process:3 st_add:520 end_add:594
process:4 st_add:594 end_add:776
allocated list:
process:5 st_add:776 end_add:876
================
process:0 st_add:0 end_add:21
free list:
process:1 st_add:21 end_add:490
=================
process:2 st_add:490 end_add:520
st_add:876 end_add:1024
free list:
process to be inserted:6 size:183
=================
there is not enough space
st_add:520 end_add:1024
allocated list:
process to be inserted:3 size:74
================
process:0 st_add:0 end_add:21
allocated list:
process:1 st_add:21 end_add:490
================
process:2 st_add:490 end_add:520
process:0 st_add:0 end_add:21
process:3 st_add:520 end_add:594
process:1 st_add:21 end_add:490
process:4 st_add:594 end_add:776
process:2 st_add:490 end_add:520
process:5 st_add:776 end_add:876
process:3 st_add:520 end_add:594
free list: free list:
================= =================
st_add:876 end_add:1024 st_add:0 end_add:21
st_add:876 end_add:1024
process to be inserted:7 size:411
there is not enough space process to be deleted:1

allocated list: allocated list:

================ ================
process:0 st_add:0 end_add:21 process:2 st_add:490 end_add:520
process:1 st_add:21 end_add:490 process:3 st_add:520 end_add:594
process:2 st_add:490 end_add:520 process:4 st_add:594 end_add:776
process:3 st_add:520 end_add:594 process:5 st_add:776 end_add:876
process:4 st_add:594 end_add:776
process:5 st_add:776 end_add:876 free list:
=================
free list: st_add:0 end_add:490
================= st_add:876 end_add:1024
st_add:876 end_add:1024
no.of process:6
process to be inserted:8 size:292 process to be inserted: 10 size :105
there is not enough space
allocated list:
allocated list: ================
================ process:2 st_add:490 end_add:520
process:0 st_add:0 end_add:21 process:3 st_add:520 end_add:594
process:1 st_add:21 end_add:490 process:4 st_add:594 end_add:776
process:2 st_add:490 end_add:520 process:5 st_add:776 end_add:876
process:3 st_add:520 end_add:594 process:10 st_add:0 end_add:105
process:4 st_add:594 end_add:776
process:5 st_add:776 end_add:876 free list:
=================
free list: st_add:105 end_add:490
================= st_add:876 end_add:1024
st_add:876 end_add:1024
process to be inserted: 11 size :93
no.of process deletion:2
allocated list:
process to be deleted:0 ================
process:2 st_add:490 end_add:520
allocated list: process:3 st_add:520 end_add:594
================ process:4 st_add:594 end_add:776
process:1 st_add:21 end_add:490 process:5 st_add:776 end_add:876
process:2 st_add:490 end_add:520 process:10 st_add:0 end_add:105
process:3 st_add:520 end_add:594 process:11 st_add:105 end_add:198
process:4 st_add:594 end_add:776
process:5 st_add:776 end_add:876
free list: process:11 st_add:105 end_add:198
================= process:12 st_add:198 end_add:258
st_add:198 end_add:490 process:13 st_add:258 end_add:361
st_add:876 end_add:1024 process:14 st_add:876 end_add:948

process to be inserted: 12 size :60 free list:

=================
allocated list: st_add:361 end_add:490
================ st_add:948 end_add:1024
process:2 st_add:490 end_add:520
process:3 st_add:520 end_add:594 process to be inserted: 15 size :17
process:4 st_add:594 end_add:776
process:5 st_add:776 end_add:876 allocated list:
process:10 st_add:0 end_add:105 ================
process:11 st_add:105 end_add:198 process:2 st_add:490 end_add:520
process:12 st_add:198 end_add:258 process:3 st_add:520 end_add:594
process:4 st_add:594 end_add:776
free list: process:5 st_add:776 end_add:876
================= process:10 st_add:0 end_add:105
st_add:258 end_add:490 process:11 st_add:105 end_add:198
st_add:876 end_add:1024 process:12 st_add:198 end_add:258
process:13 st_add:258 end_add:361
process to be inserted: 13 size :103 process:14 st_add:876 end_add:948
process:15 st_add:361 end_add:378
allocated list:
================ free list:
process:2 st_add:490 end_add:520 =================
process:3 st_add:520 end_add:594 st_add:378 end_add:490
process:4 st_add:594 end_add:776 st_add:948 end_add:1024
process:5 st_add:776 end_add:876
process:10 st_add:0 end_add:105
process:11 st_add:105 end_add:198
process:12 st_add:198 end_add:258
process:13 st_add:258 end_add:361

free list:
=================
st_add:361 end_add:490
st_add:876 end_add:1024

process to be inserted: 14 size :72

allocated list:
================
process:2 st_add:490 end_add:520
process:3 st_add:520 end_add:594
process:4 st_add:594 end_add:776
process:5 st_add:776 end_add:876
process:10 st_add:0 end_add:105