Scribd
Upload
14 views3 pages

OS Lab 6B

The document provides a C program that simulates the Best-Fit contiguous memory allocation technique, where each process is allocated to the smallest available memory block that can accommodate it. It includes structures for memory blocks and processes, a bestFit function for allocation logic, and a main function to initialize and display the allocation status. The output demonstrates the allocation of processes to memory blocks, minimizing wasted space.

Uploaded by

raghuveerprabhu2024
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
14 views3 pages

OS Lab 6B

The document provides a C program that simulates the Best-Fit contiguous memory allocation technique, where each process is allocated to the smallest available memory block that can accommodate it. It includes structures for memory blocks and processes, a bestFit function for allocation logic, and a main function to initialize and display the allocation status. The output demonstrates the allocation of processes to memory blocks, minimizing wasted space.

Uploaded by

raghuveerprabhu2024
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 3

Develop a C program to simulate the following contiguous memory allocation Techniques:

b) Best fit

C program to simulate the Best-Fit contiguous memory allocation technique. In this approach,
each incoming process is allocated to the smallest available memory block that can still
accommodate the process, minimizing wasted space within each allocated block.

The program structure is similar to the previous one for Worst-Fit, but the allocation logic now
looks for the smallest suitable block for each process.

Explanation
1. Structures:
o MemoryBlock and Process structures are the same as in the Worst-Fit version.
2. bestFit Function:
o For each process, the function searches for the smallest block that is large
enough to hold the process.
o If a suitable block is found, it is marked as allocated and assigned to the process.
If no suitable block is found, the process is denied allocation.
3. Main Function:
o Initializes arrays of memory blocks and processes.
o Calls bestFit to perform memory allocation based on the Best-Fit strategy.
o Displays the allocation status of each block after processing.

Here's the code:

#include <stdio.h>

#define MAX_BLOCKS 10
#define MAX_PROCESSES 5

// Structure to represent memory blocks


struct MemoryBlock {
int size;
int allocated; // 0 if free, 1 if allocated
};

// Structure to represent processes


struct Process {
int size;
int allocatedBlock; // Index of allocated memory block, -1 if not allocated
};

// Function to perform best-fit memory allocation


void bestFit(struct MemoryBlock blocks[], int numBlocks, struct Process processes[], int
numProcesses) {
for (int i = 0; i < numProcesses; i++) {
int bestIndex = -1; // To track the index of the smallest suitable block
for (int j = 0; j < numBlocks; j++) {
// Check if the block is free and large enough to accommodate the process
if (!blocks[j].allocated && blocks[j].size >= processes[i].size) {
// Find the smallest block that fits
if (bestIndex == -1 || blocks[j].size < blocks[bestIndex].size) {
bestIndex = j;
}
}
}

// Allocate the block to the process if found


if (bestIndex != -1) {
blocks[bestIndex].allocated = 1;
processes[i].allocatedBlock = bestIndex;
printf("Process %d allocated to block %d\n", i + 1, bestIndex + 1);
} else {
processes[i].allocatedBlock = -1;
printf("Process %d cannot be allocated\n", i + 1);
}
}
}

int main() {
struct MemoryBlock blocks[MAX_BLOCKS] = {{100, 0}, {500, 0}, {200, 0}, {300, 0}, {600, 0}};
struct Process processes[MAX_PROCESSES] = {{212, -1}, {417, -1}, {112, -1}, {426, -1}, {95,
-1}};

int numBlocks = 5; // Number of memory blocks


int numProcesses = 5; // Number of processes

printf("Best-Fit Memory Allocation\n");


bestFit(blocks, numBlocks, processes, numProcesses);

printf("\nFinal Memory Allocation:\n");


for (int i = 0; i < numBlocks; i++) {
printf("Block %d: %d KB, %s\n", i + 1, blocks[i].size, blocks[i].allocated ? "Allocated" :
"Free");
}

return 0;
}

Example Output

Best-Fit Memory Allocation


Process 1 allocated to block 4
Process 2 allocated to block 2
Process 3 allocated to block 3
Process 4 allocated to block 5
Process 5 allocated to block 1

Final Memory Allocation:


Block 1: 100 KB, Allocated
Block 2: 500 KB, Allocated
Block 3: 200 KB, Allocated
Block 4: 300 KB, Allocated
Block 5: 600 KB, Allocated

Explanation of Output
 Each process is allocated to the smallest block that can hold it, minimizing leftover space
in each allocated block.
 For example, Process 1 (212 KB) is allocated to Block 4 (300 KB) as it's the smallest
available block that can accommodate it.

You might also like