Transcript
//…….PROGRAM FOR SIMULATION OF FCFS CHEDULING ALGORITHM………..//
#include
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;iat[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
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;ibt[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
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
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;ipt[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
#include
#include
#include
#include
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
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
#include
#include
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
#include
#include
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
#include
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;i0)
{
for(i=0;i0)
{
for(i=0;i
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
#include
#include
#include
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;iend_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;ipid!=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
process to be inserted:0 size:120
no. of process:3
process to be inserted:10 size:195
allocated list:
================
process:0 st_add:0 end_add:120
free list:
=================
st_add:120 end_add:1024
process to be inserted:1 size:185
allocated list:
================
process:0 st_add:0 end_add:120
process:1 st_add:120 end_add:305
free list:
=================
st_add:305 end_add:1024
process to be inserted:2 size:246
allocated list:
================
process:0 st_add:0 end_add:120
process:1 st_add:120 end_add:305
process:2 st_add:305 end_add:551
free list:
=================
st_add:551 end_add:1024
no.of process deletion:1
process to be deleted:0
allocated list:
================
process:1 st_add:120 end_add:305
process:2 st_add:305 end_add:551
free list:
=================
st_add:0 end_add:120
allocated list:
================
process:1 st_add:120 end_add:305
process:2 st_add:305 end_add:551
process:10 st_add:551 end_add:746
free list:
=================
st_add:0 end_add:120
st_add:746 end_add:1024
process to be inserted:11 size:96
allocated list:
================
process:1 st_add:120 end_add:305
process:2 st_add:305 end_add:551
process:10 st_add:551 end_add:746
process:11 st_add:0 end_add:96
free list:
=================
st_add:96 end_add:120
st_add:746 end_add:1024
process to be inserted:12 size:148
allocated list:
================
process:1 st_add:120 end_add:305
process:2 st_add:305 end_add:551
process:10 st_add:551 end_add:746
process:11 st_add:0 end_add:96
process:12 st_add:746 end_add:894
free list:
=================
st_add:96 end_add:120
st_add:894 end_add:1024
//……PROGRAM FOR BEST FIT…...//
#include
#include
#include
#include
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;iend_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;iend_add - temp_f->st_add >= pro[i].size)
{
if(temp_f->end_add - temp_f->st_add - pro[i].sizeend_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;ipid!=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:
no. of process:7
process to be inserted:0 size:351
allocated list:
================
process:0 st_add:0 end_add:351
free list:
=================
st_add:351 end_add:1024
process to be inserted:4 size:542
there is not enough space
allocated list:
================
process:0 st_add:0 end_add:351
process:1 st_add:351 end_add:817
free list:
=================
st_add:817 end_add:1024
process to be inserted:1 size:466
process to be inserted:5 size:547
there is not enough space
allocated list:
================
process:0 st_add:0 end_add:351
process:1 st_add:351 end_add:817
allocated list:
================
process:0 st_add:0 end_add:351
process:1 st_add:351 end_add:817
free list:
=================
st_add:817 end_add:1024
free list:
=================
st_add:817 end_add:1024
process to be inserted:2 size:337
there is not enough space
process to be inserted:6 size:89
allocated list:
================
process:0 st_add:0 end_add:351
process:1 st_add:351 end_add:817
allocated list:
================
process:0 st_add:0 end_add:351
process:1 st_add:351 end_add:817
process:6 st_add:817 end_add:906
free list:
=================
st_add:817 end_add:1024
free list:
=================
st_add:906 end_add:1024
process to be inserted:3 size:410
there is not enough space
no.of process deletion:4
process to be deleted:0
allocated list:
================
process:0 st_add:0 end_add:351
process:1 st_add:351 end_add:817
free list:
=================
st_add:817 end_add:1024
allocated list:
================
process:1 st_add:351 end_add:817
process:6 st_add:817 end_add:906
free list:
=================
st_add:0 end_add:351
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:2
process not in memory
free list:
=================
st_add:155 end_add:351
st_add:906 end_add:1024
allocated list:
================
process:1 st_add:351 end_add:817
process:6 st_add:817 end_add:906
free list:
=================
st_add:0 end_add:351
st_add:906 end_add:1024
process to be inserted:11 size:43
allocated list:
================
process:1 st_add:351 end_add:817
process:6 st_add:817 end_add:906
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
allocated list:
================
process:1 st_add:351 end_add:817
process:6 st_add:817 end_add:906
free list:
=================
st_add:0 end_add:351
st_add:906 end_add:1024
free list:
=================
st_add:155 end_add:351
st_add:949 end_add:1024
process to be inserted:12 size:188
process to be deleted:4
process not in memory
allocated list:
================
process:1 st_add:351 end_add:817
process:6 st_add:817 end_add:906
process:10 st_add:0 end_add:155
process:11 st_add:906 end_add:949
process:12 st_add:155 end_add:343
allocated list:
================
process:1 st_add:351 end_add:817
process:6 st_add:817 end_add:906
free list:
=================
st_add:343 end_add:351
st_add:949 end_add:1024
free list:
=================
st_add:0 end_add:351
st_add:906 end_add:1024
process to be inserted:13 size:7
no of processes:9
process to be inserted:10 size:155
allocated list:
================
process:1 st_add:351 end_add:817
allocated list:
================
process:1 st_add:351 end_add:817
process:6 st_add:817 end_add:906
process:10 st_add:0 end_add:155
process:11 st_add:906 end_add:949
process:12 st_add:155 end_add:343
process:13 st_add:343 end_add:350
free list:
=================
st_add:350 end_add:351
st_add:949 end_add:1024
process:10 st_add:0 end_add:155
process:11 st_add:906 end_add:949
process:12 st_add:155 end_add:343
process:13 st_add:343 end_add:350
process to be inserted:14 size:160
there is not enough space
free list:
=================
st_add:350 end_add:351
st_add:949 end_add:1024
allocated list:
================
process:1 st_add:351 end_add:817
process:6 st_add:817 end_add:906
process:10 st_add:0 end_add:155
process:11 st_add:906 end_add:949
process:12 st_add:155 end_add:343
process:13 st_add:343 end_add:350
free list:
=================
st_add:350 end_add:351
st_add:949 end_add:1024
process to be inserted:15 size:100
there is not enough space
allocated list:
================
process:1 st_add:351 end_add:817
process:6 st_add:817 end_add:906
process:10 st_add:0 end_add:155
process:11 st_add:906 end_add:949
process:12 st_add:155 end_add:343
process:13 st_add:343 end_add:350
free list:
=================
st_add:350 end_add:351
st_add:949 end_add:1024
process to be inserted:16 size:198
there is not enough space
allocated list:
================
process:1 st_add:351 end_add:817
process:6 st_add:817 end_add:906
process to be inserted:17 size:51
allocated list:
================
process:1 st_add:351 end_add:817
process:6 st_add:817 end_add:906
process:10 st_add:0 end_add:155
process:11 st_add:906 end_add:949
process:12 st_add:155 end_add:343
process:13 st_add:343 end_add:350
process:17 st_add:949 end_add:1000
free list:
=================
st_add:350 end_add:351
st_add:1000 end_add:1024
process to be inserted:18 size:42
there is not enough space
allocated list:
================
process:1 st_add:351 end_add:817
process:6 st_add:817 end_add:906
process:10 st_add:0 end_add:155
process:11 st_add:906 end_add:949
process:12 st_add:155 end_add:343
process:13 st_add:343 end_add:350
process:17 st_add:949 end_add:1000
free list:
=================
st_add:350 end_add:351
st_add:1000 end_add:1024
//……PROGRAM FOR WORST FIT…...//
#include
#include
#include
#include
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;iend_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;iend_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;ipid!=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:
no. of process:9
process to be inserted:0 size:21
allocated list:
================
process:0 st_add:0 end_add:21
free list:
=================
st_add:21 end_add:1024
process to be inserted:1 size:469
allocated list:
================
process:0 st_add:0 end_add:21
process:1 st_add:21 end_add:490
free list:
=================
st_add:490 end_add:1024
process to be inserted:2 size:30
allocated list:
================
process:0 st_add:0 end_add:21
process:1 st_add:21 end_add:490
process:2 st_add:490 end_add:520
free list:
=================
st_add:520 end_add:1024
process to be inserted:3 size:74
allocated list:
================
process:0 st_add:0 end_add:21
process:1 st_add:21 end_add:490
process:2 st_add:490 end_add:520
process:3 st_add:520 end_add:594
free list:
=================
st_add:594 end_add:1024
process to be inserted:4 size:182
allocated list:
================
process:0 st_add:0 end_add:21
process:1 st_add:21 end_add:490
process:2 st_add:490 end_add:520
process:3 st_add:520 end_add:594
process:4 st_add:594 end_add:776
free list:
=================
st_add:776 end_add:1024
process to be inserted:5 size:100
allocated list:
================
process:0 st_add:0 end_add:21
process:1 st_add:21 end_add:490
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
free list:
=================
st_add:876 end_add:1024
process to be inserted:6 size:183
there is not enough space
allocated list:
================
process:0 st_add:0 end_add:21
process:1 st_add:21 end_add:490
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
free list:
=================
st_add:876 end_add:1024
process to be inserted:7 size:411
there is not enough space
allocated list:
================
process:0 st_add:0 end_add:21
process:1 st_add:21 end_add:490
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
free list:
=================
st_add:876 end_add:1024
process to be inserted:8 size:292
there is not enough space
allocated list:
================
process:0 st_add:0 end_add:21
process:1 st_add:21 end_add:490
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
free list:
=================
st_add:876 end_add:1024
=================
st_add:0 end_add:21
st_add:876 end_add:1024
process to be deleted:1
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
free list:
=================
st_add:0 end_add:490
st_add:876 end_add:1024
no.of process:6
process to be inserted: 10 size :105
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
free list:
=================
st_add:105 end_add:490
st_add:876 end_add:1024
process to be inserted: 11 size :93
no.of process deletion:2
process to be deleted:0
allocated list:
================
process:1 st_add:21 end_add:490
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
free list:
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
process:11 st_add:105 end_add:198
free list:
=================
st_add:198 end_add:490
st_add:876 end_add:1024
process:12 st_add:198 end_add:258
process:13 st_add:258 end_add:361
process:14 st_add:876 end_add:948
process to be inserted: 12 size :60
free list:
=================
st_add:361 end_add:490
st_add:948 end_add:1024
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
process:11 st_add:105 end_add:198
process:12 st_add:198 end_add:258
free list:
=================
st_add:258 end_add:490
st_add:876 end_add:1024
process to be inserted: 13 size :103
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
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
process:11 st_add:105 end_add:198
process to be inserted: 15 size :17
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
process:11 st_add:105 end_add:198
process:12 st_add:198 end_add:258
process:13 st_add:258 end_add:361
process:14 st_add:876 end_add:948
process:15 st_add:361 end_add:378
free list:
=================
st_add:378 end_add:490
st_add:948 end_add:1024