Program for First Fit algorithm in Memory Management

13 Jun, 2022
Prerequisite : Partition Allocation MethodsIn 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            3
   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. Consider the above example, process number 4 (of size 426) does not get memory. However it was possible to allocate memory if we had allocated using best fit allocation [block number 4 (of size 300) to process 1, block number 2 to process 2, block number 3 to process 3 and block number 5 to process 4].
 
 
Implementation:
1- Input memory blocks with size and processes with size.
2- Initialize all memory blocks as free.
3- Start by picking each process and check if it can
   be assigned to current block. 
4- If size-of-process <= size-of-block if yes then 
   assign and check for next process.
5- If not then keep checking the further blocks.
 
Below is an implementation of above steps. 
C++
Java
Python3
C#
Javascript
C
// C++ implementation of First - Fit algorithm#include<bits/stdc++.h>using namespace std; // Function to allocate memory to// blocks as per First fit algorithmvoid firstFit(int blockSize[], int m,              int processSize[], int n){    // Stores block id of the    // block allocated to a process    int allocation[n];     // 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++)    {        for (int j = 0; j < m; j++)        {            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;            }        }    }     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 codeint main(){    int blockSize[] = {100, 500, 200, 300, 600};    int processSize[] = {212, 417, 112, 426};    int m = sizeof(blockSize) / sizeof(blockSize[0]);    int n = sizeof(processSize) / sizeof(processSize[0]);     firstFit(blockSize, m, processSize, n);     return 0 ;}
// Java implementation of First - Fit algorithm // Java implementation of First - Fit algorithmclass 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++)            {                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;                }            }        }             System.out.println("\nProcess No.\tProcess Size\tBlock no.");        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 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;                 firstFit(blockSize, m, processSize, n);    }}
# Python3 implementation of First-Fit algorithm # Function to allocate memory to# blocks as per First fit algorithmdef firstFit(blockSize, m, processSize, n):         # Stores block id of the    # block allocated to a process    allocation = [-1] * n     # Initially no block is assigned to any process     # pick each process and find suitable blocks    # according to its size ad assign to it    for i in range(n):        for j in range(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     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 = [100, 500, 200, 300, 600]    processSize = [212, 417, 112, 426]    m = len(blockSize)    n = len(processSize)     firstFit(blockSize, m, processSize, n)     # This code is contributed by PranchalK
// C# implementation of First - Fit algorithmusing 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++)            {                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);    }} // This code is contributed by nitin mittal.
// Javascript implementation<script> const firstFit = (blockSize,m,processSize,n) => {         // Stores block id of the        // block allocated to a process        const allocation = [];             // Initially no block is assigned to any process        for (let 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 (let i = 0; i < n; i++)        {            for (let j = 0; j < m; j++)            {                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;                }            }         }                   document.write("\nProcess No.\tProcess Size\tBlock no.");        for (let i = 0; i < n; i++)        {            let s = "Not Allocated"            if (allocation[i] > -1)                document.write(" " + (i+1) + "\t\t\t\t" +                             processSize[i] + "\t\t\t\t"+ (allocation[i] + 1));            else                document.write(" " + (i+1) + "\t\t\t\t" +                             processSize[i] + "\t\t\t\tNot Allocated");                     }    }                      const blockSize = [100, 500, 200, 300, 600];        const processSize = [212, 417, 112, 426];        let m = blockSize.length;        let n = processSize.length;                 firstFit(blockSize, m, processSize, n); // This code is contributed by ashishsingh13122000.</script>
// C implementation of First - Fit algorithm#include<stdio.h> // Function to allocate memory to// blocks as per First fit algorithmvoid firstFit(int blockSize[], int m, int processSize[], int n){    int i, j;    // Stores block id of the    // block allocated to a process    int allocation[n];     // Initially no block is assigned to any process    for(i = 0; i < n; i++)    {        allocation[i] = -1;    }       // pick each process and find suitable blocks    // according to its size ad assign to it    for (i = 0; i < n; i++)        //here, n -> number of processes    {        for (j = 0; j < m; j++)        //here, m -> number of blocks        {            if (blockSize[j] >= processSize[i])            {                // allocating block j to the ith process                allocation[i] = j;                 // Reduce available memory in this block.                blockSize[j] -= processSize[i];                 break;    //go to the next process in the queue            }        }    }     printf("\nProcess No.\tProcess Size\tBlock no.\n");    for (int i = 0; i < n; i++)    {        printf(" %i\t\t\t", i+1);        printf("%i\t\t\t\t", processSize[i]);        if (allocation[i] != -1)            printf("%i", allocation[i] + 1);        else            printf("Not Allocated");        printf("\n");    }} // Driver codeint main(){    int m;    //number of blocks in the memory      int n;  //number of processes in the input queue      int blockSize[] = {100, 500, 200, 300, 600};    int processSize[] = {212, 417, 112, 426};    m = sizeof(blockSize) / sizeof(blockSize[0]);    n = sizeof(processSize) / sizeof(processSize[0]);     firstFit(blockSize, m, processSize, n);     return 0 ;}
Output :  
Process No.    Process Size    Block no.
1              212             2
2              417             5        
3              112             2
4              426             Not Allocated
 
First Fit algorithm in Memory Management | GeeksforGeeks - YouTubeGeeksforGeeks532K subscribersFirst Fit algorithm in Memory Management | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 4:21•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=RZ6674-mjrQ" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
This article is contributed by Sahil Chhabra (akku). 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. 
nitin mittal
PranchalKatiyar
priyanshuanand166
akashish__
209x1a0598
learnsmtgnewvysh
memory-management
Greedy
Greedy
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.