First Fit Algorithm in Python

The first-fit algorithm is a method used for memory allocation that allocates the memory to the requested process such that the first available block is large enough to accommodate.

Working:

The First Fit algorithm is a memory allocation strategy used in operating and computer systems to manage available memory for processes or data. It works as follows:

1. Initialization:

Initially, the memory is set to blocks. Each block is of a fixed size.

2. Allocation Request:

Whenever a new request is made by a process or a program, the system searches for the available block in the memory such that it is large enough to accommodate the requested size.

3. Searching for a Fit:

The system starts searching from the beginning of the memory and scans it until it finds the memory greater than or equal to the size requested by the process. Once the memory is found, it stops scanning.

4. Allocation:

If a suitable block is found, it is assigned to the requesting process. The allocation step involves marking the selected block as "allocated," and the allocated block's starting address (or index) is returned to the process.

5. Memory Tracking:

The system keeps track of which memory blocks are assigned and which are available.

6. Deallocation:

When a process is finished with its allotted memory, it returns it to the system. The previously allocated memory block is marked as "free" once more, making it available for future allocation requests.

The First Fit technique is simple and easy to implement. However, it might cause memory fragmentation over time. As a result, to solve fragmentation issues and optimize memory allocation, complex memory allocation algorithms such as Best Fit and Worst Fit have been created.

Example

Let us look into the implementation of the first fit algorithm in Python.

def first_fit(memory_blocks, process_sizes):
  " " " Allocates memory to processes using the First Fit algorithm.
    memory_blocks: A list of memory block sizes.
    process_sizes: A list of process sizes. " " "


  # Initialize the allocation list.
  allocations = [-1] * len(process_sizes)

  # Iterate over the processes.
  for i in range(len(process_sizes)):
    # Find the first memory block large enough to accommodate the process.
    for j in range(len(memory_blocks)):
      if memory_blocks[j] >= process_sizes[i]:
        # Allocate the memory block to the process.
        allocations[i] = j
        # Reduce the size of the memory block.
        memory_blocks[j] -= process_sizes[i]
        break

  return allocations
memory_blocks = [100, 200, 300, 200, 500, 700]
process_sizes = [50, 100, 150, 900, 400, 800]
allocations = first_fit(memory_blocks, process_sizes)
print(allocations)

Output

[0, 1, 2, -1, 4, -1]

Explanation:

The algorithm works by assigning the first available memory block large enough to accommodate each process in the order that the processes are received.

It initializes an allocation list to track which memory block is allocated to each process. The list is initialized with -1, indicating that no memory block is initially allocated to any process.

The function then iterates through the list of processes. For each process: It iterates through the list of memory blocks to find the first available block to accommodate the current process size.

When a suitable memory block is found for a process, it updates the allocations list to indicate which memory block is allocated to that process.

It reduces the size of the allocated memory block by the size of the process as memory is allocated.

The process continues until all processes have been allocated memory or until no suitable memory blocks are left for allocation.

Finally, the function returns the allocations list, which contains the memory block index allocated to each process. If a process cannot be allocated memory, its corresponding index in the allocations list remains -1.

Advantages:

7. Immediate Allocation: When a process asks for memory, First Fit can allocate memory nearly immediately by finding the first available block that fits, decreasing the requesting process's waiting time.

8. Low Algorithmic Complexity: The time complexity of the First Fit algorithm is linear in the number of memory blocks, making it computationally efficient.

9. Low Overhead: In the First Fit algorithm, the overhead of handling memory allocations and deallocations is relatively low. The bookkeeping required to maintain track of available memory blocks is minimal.

10. Efficiency: In many circumstances, the First Fit approach may allocate memory effectively, especially when memory fragmentation is low. If memory blocks are often created and deallocated, First Fit can be an excellent alternative for reducing search time.

11. Simplicity: The First Fit algorithm is easy to build and understand. It is one of the simplest memory allocation techniques, which can be advantageous when simplicity is needed.

Limitations

Fragmentation:

1. External Fragmentation:

External fragmentation occurs when several small, non-contiguous free memory blocks are dispersed throughout the memory space due to the first fit. Even if there is adequate total free memory, this fragmentation can make allocating larger memory requests difficult.

2. Internal Fragmentation:

Internal fragmentation can occur when the allocated memory block exceeds the intended size, resulting in wasted memory. It occurs when the first available block is larger than required but needs to be larger to allow numerous smaller requests.

Conclusion

To summarise, the First Fit technique is a simple and effective memory allocation method, although it has several drawbacks, most notably memory fragmentation. The system's specific requirements and limits determine its suitability for a given application. Understanding the benefits and drawbacks of First Fit is critical when deciding on the best memory allocation technique.

Next TopicGaussian-blur-algorithm-in-python

← prev next →