Best Fit Algorithm in Python

The Best Fit algorithm is a type of algorithm used for memory allocation for searching the available memory block which fits in the process. Allocating memory is an important task. The most common and simple method of allocating memory is by using the best-fit algorithm.

Best Fit Algorithm in Memory Management

The Best Fit Algorithm searches for an empty memory block. It aims to find a memory block having minimum memory wastage. Then, it allocates that memory block to the process. After the allocation, it compares the process with the memory block, and the block with minimum leftover memory is selected. The memory partition with minimum memory loss used to allocate the process is called the best fit algorithm partition.

Working of Best Fit Algorithm

The best fit algorithm repeats the list of memory blocks and searches for the ones that can fit into the process. The memory blocks are assigned with unique tags, and each process gets the block ID, which determines their corresponding memory block. The unique tag ID tells which process needs to be deleted to free up space.

There are two approaches to implementing the best fit algorithm in Python including:

Using arrays
Using a linked list

Let's implement the best fit algorithm in Python.

1. Using Arrays

Algorithm:

Declare memory blocks and processes with sizes.
Initialise all memory blocks as free.
Search the minimum block size in every process and assign it to the current process.
If the search is not found, start the process again and find the minimum block in the other process.

Implementing the best fit algorithm using arrays in Python

Code:

def bestFit_array(block_size, m, process, n):
    a = [-1] * n
    
    for i in range(n):
        b_ID = -1
        for j in range(m):
            if block_size[j] >= process[i]:
                if b_ID == -1:
                    b_ID = j
                elif block_size[b_ID] > block_size[j]:
                    b_ID = j
        if b_ID != -1:
            a[i] = b_ID
            block_size[b_ID] -= process[i]
    
    print("Process ID   Process Size   Block Number")
    for i in range(n):
        print(i + 1, "            ", process[i], end = "            ")
    
        if a[i] != -1:
            print(a[i] + 1)
        else:
            print("No memory allocated!")

if __name__ == '__main__':
    block_size = [200, 100, 900, 235, 102]
    process = [187, 122, 567, 156]
    m = len(bs)
    n = len(ps)
    
    bestFit_array(block_size, m, process, n )

Output:

Process ID   Process Size   Block Number
1              127           2
2              122           1
3              567           3
4              126           4

We made a function bestFit_array( ) and taken the block size and process size as inputs to implement the best fit algorithm using an array. Then, we stored the block IDs of all the blocks assigned to a process in a variable a. Then, we iterate for each process, search for the appropriate block according to its size, and assign it to the corresponding block number. We will then find the block best fitted to the current process. If the block is found, then the block is allocated to the process. If the block is not in the range of the process size, then no memory will be allocated to it. After the allocation, we will reduce the available memory in the block. Then, we will call the function and print the Process ID, Process Size, Block Size, and Block Number.

2. Using Linked List

Algorithm:

Create a list with the memory blocks and a list of processes.
Search for the best memory block and allocate it to the process.
If the block is not found, print the memory block and add it to the list.
Free up space for other processes by deleting the process node from the linked list.
The block ID of the deleted node will be assigned to other processes to increase the memory block size.

Implementing the best fit algorithm using the linked list

Code:

m = 0; k = 0

class free_mem: 
    def __init__(self):
        self.tag_id = -1
        self.size = 0
        self.next = None

head_free = None; prev_free = None

class allocate:
    def __init__(self):
        self.block_id = -1
        self.tag_id = -1
        self.size = 0
        self.next = None

head_alloc = None; prev_alloc = None

def free_create(c):
    global m, prev_free, head_free
    p = free_mem()
    p.size = c
    p.tag_id = m
    p.next = None
    if head_free is None:
        head_free = p
    else:
        prev_free.next = p
    prev_free = p
    m += 1
    
def free_print():
    p = head_free
    print("Tag ID  Size")
    while (p != None):
        print("[ ] [ ]",format(p.tag_id, p.size))
        p = p.next
        
def alloc_print():
    p = head_alloc
    print("Tag ID   Block ID   Size")
    while (p is not None):
        print("[ ] [ ] [ ]".format(p.tag_id, p.block_id, p.size))
        p = p.next

def alloc_create(c):
    global k, head_alloc
    q = allocate()
    q.size = c
    q.tag_id = k
    q.next = None
    p = head_free
    
    
    while (p != None) :
        if (q.size <= p.size):
            break
        p = p.next
     
    if (p != None) :
        q.block_id = p.tag_id
        p.size -= q.size
        if (head_alloc == None):
            head_alloc = q
        else :
            prev_alloc = head_alloc
            while (prev_alloc.next != None):
                prev_alloc = prev_alloc.next
            prev_alloc.next = q
         
        k+=1
     
    else:
        print("Cannot allocate Block Size [ ]".format(c))

def alloc_delete(t):
    global head_alloc
    p = head_alloc; q = None
 
    while (p != None) :
        if (p.tag_id == t):
            break
        q = p
        p = p.next
     
    if (p == None):
        print("Tag ID doesn't exist")
    elif (p == alloc_head):
        alloc_head = alloc_head.next
    else:
        q.next = p.next
    temp = head_free
    while (temp != None) :
        if (temp.tag_id == p.block_id) :
            temp.size += p.size
            break
         
        temp = temp.next

if __name__ == '__main__':
    block_Size = [100, 500, 200] 
    process_Size = [417, 112, 426, 95]
    g = len(block_Size)
    n = len(process_Size)
 
    for i in range(m):
        free_create(block_Size[i])
 
    for i in range(n):
        alloc_create(process_Size[i])
 
    alloc_print()
 
    alloc_delete(0)
 
    alloc_create(426)
    print("After Deletion:")
    alloc_print()

Output:

Cannot allocate Block Size [ ]
Tag ID	Block ID	Size
0		1		471	
1		0	      121	
2		1		85	
After deletion:
Tag ID	Block ID	Size
1		0		121	
2		1		85	
3		1		426

Explanation:

We have made classes for the allocated list and free memory list. Then, we created a function to create a list with the given size. A function to print the free list will print the free memory blocks. Then, the memory is allocated to the process according to the best fit algorithm. Then, we will delete the nodes to free the space from the list. We have called the functions with block size and object size as parameters and printed the Tag ID, Block ID, and size after allocation and deletion.

Next TopicBest-python-certification-for-data-science

← prev next →