Ex. No.: 8
|
IMPLEMENTATION
OF MEMORY MANAGEMENT SCHEME
|
Aim:
To write C program to implement Memory Allocation
using
a.
First Fit
Algorithm
b.
Best Fit
Algorithm
c.
Worst Fit
Algorithm
Problem Description:
The
memory is divided into many partitions. When a partition is free, a process is
selected form the input queue and is loaded into the free partition. When the
process terminates the partition is available for another process
Initially, all memory is available
for user processes, and it considers the available block of memory, a hole. When a process arrives and needs
memory, we search for a hole large enough for the process. If we found one, we
allocate only as much memory as is needed, keeping the rest available to
satisfy the future request.
The set of holes is searched to
determine which hole is the best to allocate. The following strategies are used
to select a free hole from the set of available holes
·
First fit: Allocate the first hole that is big enough. Searching
can start at the beginning if set of holes or where the first fit search ended.
We can stop as soon as we find a free hole that is large enough.
·
Best fit: Allocate the smallest hole that is big enough. We must
search the entire list, unless the list is kept ordered by size. This strategy
produces the smallest leftover hole
·
Worst fit: Allocate the largest hole. Again we must search the
entire list, unless it is sorted by size. This strategy produces the largest
leftover hole, which may be more useful than the smaller leftover hole from a
best-fit approach
ALGORITHM:
Step 1 : Declare
the require variables.
Step 2 : Get the memory
partition size and page size from the user.
Step 3 : Select the
algorithm based on the choice from the user using switch case.
Step 4 : For the First Fit Algorithm, find the first
memory partition which is big enough to hold that process and allocate the
memory partition to that process. Also calculate the free memory space.
Step 5 : For the Best
Fit Algorithm, find the smallest memory partition which is big enough to
hold the requesting process and allocate the memory partition to the process
and calculate the free memory space.
Step 6 : For
the Worst Fit Algorithm, find the
largest available memory partition which is big enough to hold the requesting
process and allocate the memory partition to the process and calculate the free
memory space.
Step 7 : Display the final frame size and allocated
process details and free memory space.
Step 8 : Terminate the program
Program : \\Program for memory management scheme
#include<stdio.h>
#include<conio.h>
int main()
{
int
p[20],f[20],min,minindex,n,i,j,c,f1[20],f2[20],f3[20],k=0,h=0,flag,t=0,n1;
clrscr();
printf("Enter
the number of memory partitions:\n");
scanf("%d",&n);
printf("\nEnter
the number of process");
scanf("%d",&n1);
for(i=0;i<n;i++)
{
printf("\n Enter the memory partition
size %d:",i+1);
scanf("%d",&f[i]);
f2[i]=f[i];
f3[i]=f[i];
}
for(i=0;i<n1;i++)
{
printf("\n Enter the page size
%d:",i+1);
scanf("%d",&p[i]);
}
do
{
printf("\n1.First fit\n");
printf("\n2.Best fit\n");
printf("\n3.Worse fit\n");
printf("\nEnter your choice\n");
scanf("%d",&c);
switch(c)
{
case 1:
for(i=0;i<n1;i++)
{
for(j=0;j<n;j++)
{
f1[i]=0;
if(p[i]<=f[j])
{
f1[i]=f[j];
f[j]=0;
break;
}
}
}
break;
case 2 :
for(i=0;i<n1;i++)
{
min=9999;
minindex=-1;
for(j=0;j<n;j++)
{
if(p[i]<=f2[j] && f2[j]!=0
&& min>f2[j])
{
min=f2[j];
minindex=j;
}
}
f1[i]=f[minindex];
f2[minindex]=0;
}
break;
case 3:
for(i=0;i<n1;i++)
{
f1[i]=0;
for(j=0;j<n;j++)
{
if(p[i]<f3[j])
{
k++;
if(k == 1)
f1[i]=f3[j];
if (f1[i]<=f3[j])
{
flag=1;
f1[i]=f3[j];
h=j;
}
}
}
k=0;
if(flag==1)
f3[h]=0;
}
break;
default:
printf("\n Out of choice");
}
printf("\n--------------------\n");
printf("\n|page |frame
| free \n");
printf("\n--------------------\n");
t=0;
for(i=0;i<n1;i++)
{
h=f1[i]-p[i];
if(h<0)
h=0;
printf("\n%d\t\t%d\t\t%d",p[i],f1[i],h);
t=t+h;
}
printf("\n---------------------\n");
printf("\nTotal free
space in memory:%d",t);
}while(c<4);
}
Enter
the number of memory partition: 5
Enter
the number of process4
Enter the memory partition size 1:100
Enter
the memory partition size 2:500
Enter
the memory partition size 3:200
Enter
the memory partition size 4:300
Enter
the memory partition size 5:600
Enter
the page size 1:212
Enter
the page size 2:417
Enter
the page size 3:112
Enter
the page size 4:426
1.First
fit
2.Best
fit
3.Worse
fit
Enter your choice 1
--------------------------
|page
|frame
| free
---------------------------
212 500 288
417 600 183
112 200 88
426 0 0
-----------------------------------
Total free space in memory:559
1.First
fit
2.Best
fit
3.Worse
fit
Enter your choice 2
--------------------------
|page |frame
| free
---------------------------
212 300 88
417 500 83
112 200 88
426 600 174
-----------------------------------
Total free space in memory:433
1.First
fit
2.Best
fit
3.Worse
fit
Enter
your choice 3
--------------------------
|page |frame
| free
---------------------------
212 600 388
417 500 83
112 300 188
426 0
0
-----------------------------------
Total
free space in memory:659
RESULT:
Thus
the C program to implement the allocation using First Fit, Best Fit and
Worst Fit Algorithms was written, executed and the obtained outputs were
verified.
No comments:
Post a Comment