4thLevel | Operating System.

| Lab 7

Memory Management

Program for First Fit algorithm:

In the first fit, the partition is allocated which is first sufficient from the top of
Main Memory.
Example:
Input:
blockSize[] = {100, 500, 200, 300, 600};
processSize[] = {212, 417, 112, 426};
Output:
Process No. Process Size Block no.
1 212 2
2 417 5
3 112 2
4 426 Not Allocated

• Its advantage is that it is the fastest search as it searches only the first block i.e. enough to
assign a process.
• It may have problems of not allowing processes to take space even if it was possible to
allocate.
C# imaplementation of First - Fit algorithm
using System;

class GFG
{
// Method to allocate memory to
// blocks as per First fit algorithm
static void firstFit(int[] blockSize, int m,
int[] processSize, int n)
{
// Stores block id of the block
// allocated to a process
int[] allocation = new int[n];
// Initially no block is assigned to any process
for (int i = 0; i < allocation.Length; i++)
allocation[i] = -1;

// pick each process and find suitable blocks

// according to its size ad assign to it
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m; j++)
{

Page | 1
 4thLevel | Operating System. | Lab 7
if (blockSize[j] >= processSize[i])
{
// allocate block j to p[i] process
allocation[i] = j;

// Reduce available memory in this block.

blockSize[j] -= processSize[i];

break;
}
}
}
Console.WriteLine("\nProcess No.\tProcess Size\tBlock no.");
for (int i = 0; i < n; i++)
{
Console.Write(" " + (i + 1) + "\t\t" +
processSize[i] + "\t\t");
if (allocation[i] != -1)
Console.Write(allocation[i] + 1);
else
Console.Write("Not Allocated");
Console.WriteLine();
}
}
// Driver Code
public static void Main()
{
int[] blockSize = { 100, 500, 200, 300, 600 };
int[] processSize = { 212, 417, 112, 426 };
int m = blockSize.Length;
int n = processSize.Length;

firstFit(blockSize, m, processSize, n);

}}
Output:

Program for Best Fit algorithm:

Best fit allocates the process to a partition which is the smallest sufficient partition among the
free available partitions.

Page | 2
 4thLevel | Operating System. | Lab 7
Example:
Input:
blockSize[] = {100, 500, 200, 300, 600};
processSize[] = {212, 417, 112, 426};
Output:
Process No. Process Size Block no.
1 212 4
2 417 2
3 112 3
4 426 5

C# implementation of Best - Fit algorithm

// C# implementation of Best - Fit algorithm
using System;

public class GFG

{

// Method to allocate memory to blocks

// as per Best fit
// algorithm
static void bestFit(int[] blockSize, int m,
int[] processSize, int n)
{

// Stores block id of the block

// allocated to a process
int[] allocation = new int[n];

// Initially no block is assigned to

// any process
for (int i = 0; i < allocation.Length; i++)
allocation[i] = -1;

// pick each process and find suitable

// blocks according to its size ad
// assign to it
for (int i = 0; i < n; i++)
{

// Find the best fit block for

// current process
int bestIdx = -1;
for (int j = 0; j < m; j++)
{
if (blockSize[j] >= processSize[i])
{
if (bestIdx == -1)

Page | 3
 4thLevel | Operating System. | Lab 7
bestIdx = j;
else if (blockSize[bestIdx]
> blockSize[j])
bestIdx = j;
}
}
// If we could find a block for
// current process
if (bestIdx != -1)
{

// allocate block j to p[i]

// process
allocation[i] = bestIdx;

// Reduce available memory in

// this block.
blockSize[bestIdx] -= processSize[i];
}
}

Console.WriteLine("\nProcess No.\tProcess"
+ " Size\tBlock no.");
for (int i = 0; i < n; i++)
{
Console.Write(" " + (i + 1) + "\t\t"
+ processSize[i] + "\t\t");

if (allocation[i] != -1)
Console.Write(allocation[i] + 1);
else
Console.Write("Not Allocated");

Console.WriteLine();
}
}
// Driver Method
public static void Main()
{
int[] blockSize = { 100, 500, 200, 300, 600 };
int[] processSize = { 212, 417, 112, 426 };
int m = blockSize.Length;
int n = processSize.Length;

bestFit(blockSize, m, processSize, n);

}
}
Output:

Page | 4
 4thLevel | Operating System. | Lab 7
Is Best-Fit really best?
Although, best fit minimizes the wastage space, it consumes a lot of processor time for
searching the block which is close to required size. Also, Best-fit may perform poorer than
other algorithms in some cases.

Program for Worst Fit algorithm:

Worst Fit allocates a process to the partition which is largest sufficient among the freely
available partitions available in the main memory. If a large process comes at a later stage,
then memory will not have space to accommodate it.
Example:
Input:
blockSize[] = {100, 500, 200, 300, 600};
processSize[] = {212, 417, 112, 426};
Output:
Process No. Process Size Block no.
1 212 5
2 417 2
3 112 5
4 426 Not Allocated

C# implementation of worst - Fit algorithm

using System;
class GFG
{
// Method to allocate memory to blocks
// as per worst fit algorithm
static void worstFit(int[] blockSize, int m,
int[] processSize, int n)
{
// Stores block id of the block allocated to a
// process
int[] allocation = new int[n];

// Initially no block is assigned to any process

for (int i = 0; i < allocation.Length; i++)
allocation[i] = -1;

// pick each process and find suitable blocks

// according to its size ad assign to it
for (int i = 0; i < n; i++)
{
// Find the best fit block for current process
int wstIdx = -1;
for (int j = 0; j < m; j++)

Page | 5
 4thLevel | Operating System. | Lab 7
{
if (blockSize[j] >= processSize[i])
{
if (wstIdx == -1)
wstIdx = j;
else if (blockSize[wstIdx] < blockSize[j])
wstIdx = j;
}
}

// If we could find a block for current process

if (wstIdx != -1)
{
// allocate block j to p[i] process
allocation[i] = wstIdx;

// Reduce available memory in this block.

blockSize[wstIdx] -= processSize[i];
}
}
Console.WriteLine("\nProcess No.\tProcess Size\tBlock no.");
for (int i = 0; i < n; i++)
{
Console.Write(" " + (i + 1) + "\t\t" + processSize[i] + "\t\t");
if (allocation[i] != -1)
Console.Write(allocation[i] + 1);
else
Console.Write("Not Allocated");
Console.WriteLine();
}
}
// Driver code
public static void Main(String[] args)
{
int[] blockSize = { 100, 500, 200, 300, 600 };
int[] processSize = { 212, 417, 112, 426 };
int m = blockSize.Length;
int n = processSize.Length;

worstFit(blockSize, m, processSize, n);

}}

Output:

******************

Page | 6