First Fit Program in C

This is one of the easiest ways to allocate memory. The main goal is to divide the memory into several fixed sizes. In C, there is only one process for each partition of the First Fit program. The operating system has three memory management schemes: First Fit, Worst Fit, and Best Fit.

What is First Fit?

 Empty memory blocks are checked sequentially with the first matching memory allocation. This indicates that the memory block size found to be empty on the first try is being checked. However, if the size is greater than or equal to the required size, it will be allocated.

Advantage:

• This is the fastest search algorithm because it doesn't need to search every block.

Disadvantages:

• The main drawback of First Fit is that other processes cannot use the extra memory. Allocating memory creates large chunks of disk space.

Memory Management Plan for the First Fit

The First Fit memory management scheme compares the size of the first process to the size of the first block when checking blocks. Only this block is allocated if its size is smaller than the first block. If not, go to the second block and continue processing until all processes are allocated.

The partition that is first sufficient from the top of the Main Memory is allocated during the first fit.

It has the advantage of being the quickest search because it only searches the first block, which is sufficient to assign a process.

Even if space could be allocated, it might have issues with processes taking up space.Take process number 4 (with a size of 426) as an example. It does not receive memory.However, we could allocate the memory if we used best fit allocation to allocate blocks 4 (of size 300) to process 1, 2 to process 2, 3 to process 3, and 5 to process 4.

First Fitting Algorithm

Step 1: Get started.

Step 2: First, determine the number of processes and blocks.

Step 3: Allocate the process if the block size is larger than the process size. Otherwise, proceed to the next block.

Step 4: View the process in blocks and allocate resources to each.

Step 5: Stop. We talked about how it works and the algorithms.

Here is the First Fit program in C:

#include<stdio.h>
void main()
{
	int bsize[10], psize[10], bno, pno, flags[10], allocation[10], i, j;
	for(i = 0; i< 10; i++)
	{
		flags[i] = 0;
		allocation[i] = -1;
	}
	printf("Enter no. of blocks: ");
	scanf("%d", &bno);
	printf("\nEnter size of each block: ");
	for(i = 0; i<bno; i++)
		scanf("%d", &bsize[i]);
	printf("\nEnter no. of processes: ");
	scanf("%d", &pno);
	printf("\nEnter size of each process: ");
	for(i = 0; i<pno; i++)
		scanf("%d", &psize[i]);
//display allocation details
	printf("\nBlock no.\tsize\t\tprocess no.\t\tsize");
for(i = 0; i<bno; i++)
	{
		printf("\n%d\t\t%d\t\t", i+1, bsize[i]);
		if(flags[i] == 1)
			printf("%d\t\t\t%d",allocation[i]+1,psize[allocation[i]]);
		else
			printf("Not allocated");
	}
}

Output:

Enter no. of blocks: 3
Enter size of each block. 10
15
20
Enter no. of processes: 3
Enter size of each process : 14
12 
18
Block no.             size                   process no.               size
1                           10                     not allowed               
2                           15                    1                                  14
3                           20                    2                                  12

One of themost important functions of an operating system is memory allocation. Memory is also required for various processes that consume CPU processing time. This memory is allocated to various processes as needed. The three most common memory allocation schemes are best t fit, initial fit, and worst fit, what is Best Fit?

The operating system looks for the bestmemory allocation scheme for process p1: An empty block of memorythat can accommodate process P1. After allocating process p1 from all blocks, the memory waste is minimal. This plan is the most effective strategy because it provides optimal memory allocation. However, finding the optimal memory allocation can be time-consuming.

The first-fit algorithm is the easiest way to have all processesshare memory blocks. Pointers accept requests to allocate blocks of memoryto subsequent processes, and the algorithm keeps track of all available blocks in memory. The pointer then searches for the first largestfree memory block in the process and passes this memory block to the next process. This creates two partitions, one for the hall and one for the process.