Program for Next Fit algorithm in Memory Management
Prerequisite: Partition allocation methods
What is Next Fit?
The next fit is a modified version of ‘first fit’. It begins as the first fit to find a free partition but when called next time it starts searching from where it left off, not from the beginning. This policy makes use of a roving pointer. The pointer moves along the memory chain to search for the next fit. This helps in, to avoid the usage of memory always from the head (beginning) of the free blockchain.
What is its advantage over first fit?
- First fit is a straight and fast algorithm, but tends to cut a large portion of free parts into small pieces due to which, processes that need a large portion of memory block would not get anything even if the sum of all small pieces is greater than it required which is so-called external fragmentation problem.
- Another problem of the first fit is that it tends to allocate memory parts at the beginning of the memory, which may lead to more internal fragments at the beginning. Next fit tries to address this problem by starting the search for the free portion of parts not from the start of the memory, but from where it ends last time.
- Next fit is a very fast searching algorithm and is also comparatively faster than First Fit and Best Fit Memory Management Algorithms.
Example:
Input : blockSize[] = {5, 10, 20};
processSize[] = {10, 20, 30};
Output:
Process No. Process Size Block no.
1 10 2
2 20 3
3 30 Not Allocated
Algorithm:
- Input the number of memory blocks and their sizes and initializes all the blocks as free.
- Input the number of processes and their sizes.
- Start by picking each process and check if it can be assigned to the current block, if yes, allocate the required memory and check for next process but from the block where we left not from starting.
- If the current block size is smaller then keep checking the further blocks.
Below is the implementation of the above approach:
C++
Java
import java.util.*;
public class GFG {
static void NextFit( int blockSize[], int m, int processSize[], int n) {
int allocation[] = new int [n], j = 0 , t = m - 1 ;
Arrays.fill(allocation, - 1 );
for ( int i = 0 ; i < n; i++){
while (j < m){
if (blockSize[j] >= processSize[i]){
allocation[i] = j;
blockSize[j] -= processSize[i];
t = (j - 1 ) % m;
break ;
}
if (t == j){
t = (j - 1 ) % m;
break ;
}
j = (j + 1 ) % m;
}
}
System.out.print( "\nProcess No.\tProcess Size\tBlock no.\n" );
for ( int i = 0 ; i < n; i++) {
System.out.print( i + 1 + "\t\t\t\t" + processSize[i]
+ "\t\t\t\t" );
if (allocation[i] != - 1 ) {
System.out.print(allocation[i] + 1 );
} else {
System.out.print( "Not Allocated" );
}
System.out.println( "" );
}
}
public static void main(String[] args) {
int blockSize[] = { 5 , 10 , 20 };
int processSize[] = { 10 , 20 , 5 };
int m = blockSize.length;
int n = processSize.length;
NextFit(blockSize, m, processSize, n);
}
}
|
Python3
def NextFit(blockSize, m, processSize, n):
allocation = [ - 1 ] * n
j = 0
t = m - 1
for i in range (n):
while j < m:
if blockSize[j] > = processSize[i]:
allocation[i] = j
blockSize[j] - = processSize[i]
t = (j - 1 ) % m
break
if t = = j:
t = (j - 1 ) % m
break
j = (j + 1 ) % m
print ( "Process No. Process Size Block no." )
for i in range (n):
print ( "\t" , i + 1 , "\t\t\t" , processSize[i],end = "\t\t\t" )
if allocation[i] ! = - 1 :
print (allocation[i] + 1 )
else :
print ( "Not Allocated" )
if __name__ = = '__main__' :
blockSize = [ 5 , 10 , 20 ]
processSize = [ 10 , 20 , 5 ]
m = len (blockSize)
n = len (processSize)
NextFit(blockSize, m, processSize, n)
|
C#
PHP
Javascript
function NextFit(blockSize, m, processSize, n) {
let allocation = new Array(n).fill(-1);
let j = 0, t = m - 1;
for (let i = 0; i < n; i++) {
while (j < m) {
if (blockSize[j] >= processSize[i]) {
allocation[i] = j;
blockSize[j] -= processSize[i];
t = (j - 1) % m;
break ;
}
if (t == j) {
t = (j - 1) % m;
break ;
}
j = (j + 1) % m;
}
}
console.log( "\nProcess No.\tProcess Size\tBlock no.\n" );
for (let i = 0; i < n; i++) {
console.log( " " + (i + 1) + "\t\t\t\t" + processSize[i] + "\t\t\t\t" );
if (allocation[i] != -1)
console.log(allocation[i] + 1);
else
console.log( "Not Allocated" );
console.log( "\n" );
}
}
let blockSize = [5, 10, 20];
let processSize = [10, 20, 5];
let m = blockSize.length;
let n = processSize.length;
NextFit(blockSize, m, processSize, n);
|
Output
Process No. Process Size Block no.
1 10 2
2 20 3
3 5 1
Time Complexity: O(N*M) where N is processSize length and M is blockSize length.
Auxiliary Space: O(N)
How does the Next Fit algorithm help in reducing memory fragmentation?
The Next Fit algorithm helps in reducing memory fragmentation by leaving larger gaps between allocated partitions, which can be used for future allocations. This reduces the number of small gaps and helps in allocating larger contiguous blocks of memory to processes.
Last Updated :
05 May, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...