memory_allocation.c

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void displayResults(int allocation[], int processSize[], int temp[],
                    int original[], int processes, int blocks)
{
    int allocatedMemory = 0;
    int totalMemory = 0;
    int externalFragmentation = 0;

    printf("\nProcess\tSize\tAllocated Block\n");

    for(int i=0;i<processes;i++)
    {
        if(allocation[i]!=-1)
        {
            printf("P%d\t%d\t%d\n",i+1,processSize[i],allocation[i]+1);
            allocatedMemory += processSize[i];
        }
        else
        {
            printf("P%d\t%d\tNot Allocated\n",i+1,processSize[i]);
        }
    }

    printf("\nRemaining Memory Blocks\n");

    for(int i=0;i<blocks;i++)
    {
        printf("Block %d : %d\n",i+1,temp[i]);
        totalMemory += original[i];
        externalFragmentation += temp[i];
    }

    printf("\nMemory Utilization : %.2f%%\n",
           (allocatedMemory*100.0)/totalMemory);

    printf("External Fragmentation : %d\n",
           externalFragmentation);
}

void firstFit(int blockSize[],int blocks,int processSize[],int processes)
{
    int temp[100];
    int allocation[100];

    for(int i=0;i<blocks;i++)
        temp[i]=blockSize[i];

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

    for(int i=0;i<processes;i++)
    {
        for(int j=0;j<blocks;j++)
        {
            if(temp[j]>=processSize[i])
            {
                allocation[i]=j;
                temp[j]-=processSize[i];
                break;
            }
        }
    }

    printf("\n========== FIRST FIT ==========\n");
    displayResults(allocation,processSize,temp,blockSize,processes,blocks);
}

void bestFit(int blockSize[],int blocks,int processSize[],int processes)
{
    int temp[100];
    int allocation[100];

    for(int i=0;i<blocks;i++)
        temp[i]=blockSize[i];

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

    for(int i=0;i<processes;i++)
    {
        int best=-1;

        for(int j=0;j<blocks;j++)
        {
            if(temp[j]>=processSize[i])
            {
                if(best==-1 || temp[j]<temp[best])
                    best=j;
            }
        }

        if(best!=-1)
        {
            allocation[i]=best;
            temp[best]-=processSize[i];
        }
    }

    printf("\n========== BEST FIT ==========\n");
    displayResults(allocation,processSize,temp,blockSize,processes,blocks);
}

void worstFit(int blockSize[],int blocks,int processSize[],int processes)
{
    int temp[100];
    int allocation[100];

    for(int i=0;i<blocks;i++)
        temp[i]=blockSize[i];

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

    for(int i=0;i<processes;i++)
    {
        int worst=-1;

        for(int j=0;j<blocks;j++)
        {
            if(temp[j]>=processSize[i])
            {
                if(worst==-1 || temp[j]>temp[worst])
                    worst=j;
            }
        }

        if(worst!=-1)
        {
            allocation[i]=worst;
            temp[worst]-=processSize[i];
        }
    }

    printf("\n========== WORST FIT ==========\n");
    displayResults(allocation,processSize,temp,blockSize,processes,blocks);
}

int main()
{
    int blocks,processes;

    printf("Dynamic Memory Partitioning Simulator\n\n");

    printf("Enter number of memory blocks : ");
    scanf("%d",&blocks);

    int blockSize[100];

    printf("Enter block sizes:\n");

    for(int i=0;i<blocks;i++)
        scanf("%d",&blockSize[i]);

    printf("Enter number of processes : ");
    scanf("%d",&processes);

    int processSize[100];

    printf("Enter process sizes:\n");

    for(int i=0;i<processes;i++)
        scanf("%d",&processSize[i]);

    clock_t start,end;

    start=clock();
    firstFit(blockSize,blocks,processSize,processes);
    end=clock();

    printf("\nExecution Time : %lf sec\n",
           ((double)(end-start))/CLOCKS_PER_SEC);

    start=clock();
    bestFit(blockSize,blocks,processSize,processes);
    end=clock();

    printf("\nExecution Time : %lf sec\n",
           ((double)(end-start))/CLOCKS_PER_SEC);

    start=clock();
    worstFit(blockSize,blocks,processSize,processes);
    end=clock();

    printf("\nExecution Time : %lf sec\n",
           ((double)(end-start))/CLOCKS_PER_SEC);

    return 0;
}