First Fit Algorithm in Python

Introduction

Operating systems and computer science frequently use the First Fit algorithm, a primary memory allocation technique. Incoming programs or data segments can be efficiently allocated memory inside a contiguous memory space by using this method. The memory that is available to the algorithm is partitioned into fixed-sized sections. The First Fit method sequentially scans these partitions when a new process or data segment requires memory, choosing the first one that is big enough to serve the request.

Algorithm

A straightforward memory allocation technique called the First Fit Algorithm operates as follows:

• The memory is composed of several fixed-size blocks.
• When a process requests memory, the approach seeks the first memory block large enough to hold the needed memory.
• If the block size exceeds the desired RAM, it is divided into two parts. The first is given to the process, and the second is put back into the memory pool that is always available.
• The process is placed on a waiting list until a block becomes available if no suitable block is discovered.
• The technique combines neighbouring free blocks to create larger blocks when a process releases memory.

Example

class MemoryPartition:

    def __init__(self, size):

        self.size = size

        self.available = True

        self.process_id = None

class MemoryManager:

    def __init__(self, total_memory):

        self.total_memory = total_memory

        self.memory = [MemoryPartition(total_memory)]

    def first_fit_allocate(self, process_id, size):

        for partition in self.memory:

            if partition.available and partition.size >= size:

                partition.available = False

                partition.process_id = process_id

                return True

        return False

    def deallocate(self, process_id):

        for partition in self.memory:

            if not partition.available and partition.process_id == process_id:

                partition.available = True

                partition.process_id = None

                return True

        return False

    def display_memory(self):

        for i, partition in enumerate(self.memory):

            status = "Occupied" if not partition.available else "Free"

            print(f"Partition {i}: {status} (Size: {partition.size} KB, Process ID: {partition.process_id})")

if __name__ == "__main__":

    manager = MemoryManager(total_memory=1024)

    manager.display_memory()

    print()

    process1_size = 300

    process2_size = 500

    process3_size = 200

    allocated1 = manager.first_fit_allocate(process_id=1, size=process1_size)

    allocated2 = manager.first_fit_allocate(process_id=2, size=process2_size)

    allocated3 = manager.first_fit_allocate(process_id=3, size=process3_size)

    if allocated1:

        print(f"Allocated {process1_size} KB for Process 1")

    if allocated2:

        print(f"Allocated {process2_size} KB for Process 2")

    if allocated3:

        print(f"Allocated {process3_size} KB for Process 3")

    manager.display_memory()

    print()

    deallocated = manager.deallocate(process_id=2)

    if deallocated:

        print("Deallocated memory for Process 2")

    manager.display_memory()

Output

Partition 0: Free (Size: 1024 KB, Process ID: None)

Allocated 300 KB for Process 1

Partition 0: Occupied (Size: 1024 KB, Process ID: 1)

Partition 0: Occupied (Size: 1024 KB, Process ID: 1)

>

Explanation

The Python First Fit algorithm is used in the code to simulate a straightforward memory allocation scheme. It creates a class called MemoryManager that controls a single memory partition with a starting size of 1024 KB. Memory allocation and deallocation operations are supported by the class. Memory allocation requests from processes are handled by the First Fit algorithm, which allocates the first partition that is free to house the operation. The code shows the state of memory partitions and keeps track of their occupancy. The example shows how First Fit manages memory allocation while keeping track of the partition's occupancy by allocating memory for three processes, then deallocating memory for one.

Advantages

A simple memory allocation algorithm is the First Fit Algorithm. It offers the following benefits:

• It is easy to build and has very low overhead in terms of processing.
• It can be used in real time since it guarantees a quick response time.
• It can handle a range of memory requests as it searches for the first memory block large enough to hold the needed memory.
• Efficient and straightforward for allocating memory to processes.

Conclusion

The Python First Fit algorithm is used in the code to simulate a straightforward memory allocation scheme. It creates a class called MemoryManager that controls a single memory partition with a starting size of 1024 KB. The course supports memory allocation and deallocation operations. Memory allocation requests from processes are handled by the First Fit algorithm, which allocates the first partition that is free to house the operation. The code shows the state of memory partitions and keeps track of their occupancy. The example shows how First Fit manages memory allocation while keeping track of the partition's occupancy by allocating memory for three processes, then deallocating memory for one.