Program for Next Fit algorithm in Memory Management

25 Apr, 2022
Prerequisite: Partition allocation methods What is Next Fit ? 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 a next fit. This helps in, to avoid the usage of memory always from the head (beginning) of the free block chain. What are its advantage over first fit ?  
First fit is a straight and fast algorithm, but tends to cut 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 it 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.
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 it 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.
 
 
C++
Java
Python3
C#
PHP
Javascript
// C/C++ program for next fit// memory management algorithm#include <bits/stdc++.h>using namespace std; // Function to allocate memory to blocks as per Next fit// algorithmvoid NextFit(int blockSize[], int m, int processSize[], int n){    // Stores block id of the block allocated to a    // process    int allocation[n], j = 0;     // Initially no block is assigned to any process    memset(allocation, -1, sizeof(allocation));     // pick each process and find suitable blocks    // according to its size ad assign to it    for (int i = 0; i < n; i++) {         // Do not start from beginning        while (j < m) {             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;            }             // mod m will help in traversing the blocks from            // starting block after we reach the end.            j = (j + 1) % m;        }    }     cout << "\nProcess No.\tProcess Size\tBlock no.\n";    for (int i = 0; i < n; i++) {        cout << " " << i + 1 << "\t\t" << processSize[i]             << "\t\t";        if (allocation[i] != -1)            cout << allocation[i] + 1;        else            cout << "Not Allocated";        cout << endl;    }} // Driver programint main(){    int blockSize[] = { 5, 10, 20 };    int processSize[] = { 10, 20, 5 };    int m = sizeof(blockSize) / sizeof(blockSize[0]);    int n = sizeof(processSize) / sizeof(processSize[0]);     NextFit(blockSize, m, processSize, n);     return 0;}
// Java program for next fit// memory management algorithmimport java.util.Arrays; public class GFG { // Function to allocate memory to blocks as per Next fit// algorithm    static void NextFit(int blockSize[], int m, int processSize[], int n) {        // Stores block id of the block allocated to a        // process        int allocation[] = new int[n], j = 0;         // Initially no block is assigned to any process        Arrays.fill(allocation, -1);         // pick each process and find suitable blocks        // according to its size ad assign to it        for (int i = 0; i < n; i++) {             // Do not start from beginning            int count =0;            while (j < m) {                count++;    //makes sure that for every process we traverse through entire array maximum once only.This avoids the problem of going into infinite loop if memory is not available                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;                }                 // mod m will help in traversing the blocks from                // starting block after we reach the end.                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" + processSize[i]                    + "\t\t");            if (allocation[i] != -1) {                System.out.print(allocation[i] + 1);            } else {                System.out.print("Not Allocated");            }            System.out.println("");        }    } // Driver program    static public 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);    }} // This code is contributed by Rajput-Ji
# Python3 program for next fit# memory management algorithm # Function to allocate memory to# blocks as per Next fit algorithmdef NextFit(blockSize, m, processSize, n):             # Stores block id of the block    # allocated to a process     # Initially no block is assigned    # to any process    allocation = [-1] * n    j = 0    t = m-1    # pick each process and find suitable blocks    # according to its size ad assign to it    for i in range(n):         # Do not start from beginning        while j < m:            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]                                 # sets a new end point                t = (j - 1) % m                break            if t == j:                # sets a new end point                t = (j - 1) % m                # breaks the loop after going through all memory block                break                         # mod m will help in traversing the            # blocks from starting block after            # we reach the end.            j = (j + 1) % m                  print("Process No. Process Size Block no.")         for i in range(n):        print(i + 1, "         ", processSize[i],end = "     ")        if allocation[i] != -1:            print(allocation[i] + 1)        else:            print("Not Allocated") # Driver Codeif __name__ == '__main__':    blockSize = [5, 10, 20]    processSize = [10, 20, 5]    m = len(blockSize)    n = len(processSize)     NextFit(blockSize, m, processSize, n)
// C# program for next fit// memory management algorithmusing System;using System.Linq;public class GFG { // Function to allocate memory to blocks as per Next fit// algorithm    static void NextFit(int []blockSize, int m,                            int []processSize, int n) {        // Stores block id of the block allocated to a        // process        int []allocation = new int[n];        int j = 0;         // Initially no block is assigned to any process        Enumerable.Repeat(-1, n).ToArray();         // pick each process and find suitable blocks        // according to its size ad assign to it        for (int i = 0; i < n; i++) {             // Do not start from beginning            while (j < m) {                 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;                }                 // mod m will help in traversing the blocks from                // starting block after we reach the end.                j = (j + 1) % m;            }        }         Console.Write("\nProcess No.\tProcess Size\tBlock no.\n");        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 program    static public void Main() {        int []blockSize = {5, 10, 20};        int []processSize = {10, 20, 5};        int m = blockSize.Length;        int n = processSize.Length;        NextFit(blockSize, m, processSize, n);    }} /*This code is contributed by Rajput-Ji*/
<?php// PHP program for next fit// memory management algorithm // Function to allocate memory to blocks as per Next fit// algorithmfunction NextFit($blockSize, $m, $processSize, $n){    // Stores block id of the block allocated to a    // process    $allocation = array_fill(0, $n, -1);    $j = 0;     // Initially no block is assigned to any process above     // pick each process and find suitable blocks    // according to its size ad assign to it    for ($i = 0; $i < $n; $i++)    {         // Do not start from beginning        while ($j < $m)        {             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;            }             // mod m will help in traversing the blocks from            // starting block after we reach the end.            $j = ($j + 1) % $m;        }    }     echo "\nProcess No.\tProcess Size\tBlock no.\n";    for ($i = 0; $i < $n; $i++)    {        echo " ".($i + 1)."\t\t".$processSize[$i]."\t\t";        if ($allocation[$i] != -1)            echo ($allocation[$i] + 1);        else            echo "Not Allocated";        echo "\n";    }}     // Driver program    $blockSize = array( 5, 10, 20 );    $processSize = array( 10, 20, 5 );    $m = count($blockSize);    $n = count($processSize);     NextFit($blockSize, $m, $processSize, $n);  // This code is contributed by mits?>
<script> // JavaScript program for next fit// memory management algorithm // Function to allocate memory to blocks as per Next fit// algorithm    function NextFit(blockSize, m, processSize, n) {        // Stores block id of the block allocated to a        // process        let allocation = Array.from({length: n}, (_, i) => -1), j = 0;            // pick each process and find suitable blocks        // according to its size ad assign to it        for (let i = 0; i < n; i++) {               // Do not start from beginning            while (j < m) {                   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;                }                   // mod m will help in traversing the blocks from                // starting block after we reach the end.                j = (j + 1) % m;            }        }           document.write("\nProcess No. Process Size. Block no." + "<br/>");        for (let i = 0; i < n; i++) {            document.write( i + 1 + Array(20).fill('\xa0').join('') + processSize[i]                    + Array(20).fill('\xa0').join(''));            if (allocation[i] != -1) {                document.write(allocation[i] + 1);            } else {                document.write("Not Allocated");            }           document.write("<br/>");        }    } // Driver Code         let blockSize = [5, 10, 20];        let processSize = [10, 20, 5];        let m = blockSize.length;        let n = processSize.length;        NextFit(blockSize, m, processSize, n); // This code is contributed by susmitakundugoaldanga.</script>
Process No.    Process Size    Block no.
 1               10              2
 2               20              3
 3               5               1
 
This article is contributed by Akash Gupta. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
ishita_thakkar
Rajput-Ji
PranchalKatiyar
Akanksha_Rai
Mithun Kumar
susmitakundugoaldanga
vidulamagdum12
dhruvmillu
Greedy
Operating Systems
Operating Systems
Greedy
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Huffman Coding | Greedy Algo-3
Coin Change | DP-7
Activity Selection Problem | Greedy Algo-1
Fractional Knapsack Problem
Job Sequencing Problem
Types of Operating Systems
Banker's Algorithm in Operating System
Disk Scheduling Algorithms
Introduction of Deadlock in Operating System
Inter Process Communication (IPC)