First Fit Algorithm in C

Introduction:

The First Fit Algorithm is a memory allocation algorithm used in computer science. It is used to allocate memory blocks to processes or programs as they are requested. In this algorithm, the process is given access to the first block of memory that is sufficiently big to accommodate the required amount of memory.

First Fit Algorithm:

The First Fit Algorithm is a simple memory allocation algorithm that works as follows:

Many fixed-size blocks make up the memory.
The technique looks for the first memory block that is big enough to hold the required memory when a process requests memory.
The block is broken into two pieces if it exceeds the requested memory. The first portion is allotted to the process, while the second portion is returned to the pool of memory that is readily available.
If no suitable block is found, the process is put on a waiting list until a block becomes available.
When a process releases memory, the algorithm merges adjacent free blocks to form larger blocks.

C Code for First Fit Algorithm:

The following is the C code for the First Fit algorithm:

C Code:

#include <stdio.h>

#define MEMORY_SIZE 1000
#define BLOCK_SIZE 20

int memory[MEMORY_SIZE];

void initialize_memory() {
    int i;
    for (i = 0; i < MEMORY_SIZE; i += BLOCK_SIZE) {
        memory[i] = BLOCK_SIZE;
    }
}

void print_memory() {
    int i;
    for (i = 0; i < MEMORY_SIZE; i += BLOCK_SIZE) {
        printf("%d ", memory[i]);
    }
    printf("\n");
}

void allocate_memory(int process_id, int size) {
    int i;
    for (i = 0; i < MEMORY_SIZE; i += BLOCK_SIZE) {
        if (memory[i] >= size) {
            printf("Process %d allocated block %d of size %d\n", process_id, i/BLOCK_SIZE, size);
            memory[i] -= size;
            if (memory[i] == 0) {
                printf("Block %d freed\n", i/BLOCK_SIZE);
            }
            break;
        }
    }
    if (i == MEMORY_SIZE) {
        printf("Process %d is waiting for memory\n", process_id);
    }
}

void release_memory(int process_id, int block_id) {
    int i = block_id * BLOCK_SIZE;
    int size = BLOCK_SIZE;
    while (memory[i] == 0) {
        i -= BLOCK_SIZE;
        size += BLOCK_SIZE;
    }
    printf("Block %d of size %d freed by process %d\n", i/BLOCK_SIZE, size, process_id);
    memory[i] += size;
}

int main() {
    initialize_memory();
    allocate_memory(1, 50);
    allocate_memory(2, 100);
    allocate_memory(3, 30);
    print_memory();
    release_memory(2, 2);
    print_memory();
    allocate_memory(4, 25);
    print_memory();
    return 0;
}

In the above code, the memory is initialized using the initialize_memory() function. The memory is divided into fixed-size blocks, and each block is initialized with the block size.

The allocate_memory() function is used to allocate memory to a process. It looks for the first memory block that is big enough to hold the specified amount of memory. If a suitable block is found, the block is divided into two parts, and the first part is allocated to the process.

A process can release memory which is no longer required by it by using the release memory() function. To create larger blocks, it combines nearby free blocks.

Advantages and Limitations:

The First Fit Algorithm is a simple and easy-to-implement memory allocation algorithm. It has the following advantages:

It has very little processing overhead and is simple to implement.
Because it ensures a rapid response time, it can be employed in real-time systems.
As it looks for the first memory block that is big enough to hold the required memory, it can handle a variety of memory requests.

However, the First Fit algorithm has some limitations:

It may not result in optimal memory utilization. The algorithm may leave small fragments of memory that cannot be used for any other process. This problem can be addressed using other memory allocation algorithms, such as Best Fit and Worst Fit. However, these algorithms are more complex than the First Fit algorithm.
It may lead to Memory Fragmentation. As the algorithm allocates memory based on the first available block, it may result in small blocks of memory being left unused between allocated blocks. This can lead to Memory Fragmentation, which can affect the performance of the system.
Process waiting times could become very long as a result.As the algorithm searches for the first available memory block, it may take longer to allocate the memory if there are no available blocks that are large enough to accommodate the requested memory.

Conclusion:

The First Fit Algorithm is a simple and easy-to-implement memory allocation algorithm. It is the mostly used algorithm for memory allocation in operating systems. The algorithm finds the first chunk of memory that is big enough to hold the specified amount of memory. If a suitable block is found, the block is divided into two parts, and the first part is allocated to the process.

The First Fit algorithm in C was covered in this article. We have provided the C code for the algorithm, which can be easily modified to suit specific requirements. The code can be used as a starting point for implementing the First Fit Algorithm in larger projects.

Next TopicHello World Program in C

← prev next →