Aim:-
Memory Management: WAP to demonstrate the concept of dynamic partitioning replacement
algorithms:
a. First Fit
Code:-
#include <stdio.h>
#define MEMORY_SIZE 100
#define MAX_PARTITIONS 10
typedef struct {
int start_address;
int end_address;
int size;
int allocated;
} Partition;
Partition memory[MAX_PARTITIONS];
int num_partitions = 0;
// Function to initialize memory
void initializeMemory() {
memory[0].start_address = 0;
memory[0].end_address = MEMORY_SIZE - 1;
memory[0].size = MEMORY_SIZE;
memory[0].allocated = 0;
num_partitions = 1;
}
// Function to display memory
void displayMemory() {
printf("Memory Layout:\n");
printf("Start Address\tEnd Address\tSize\tAllocated\n");
for (int i = 0; i < num_partitions; i++) {
printf("%d\t\t%d\t\t%d\t%s\n", memory[i].start_address, memory[i].end_address,
memory[i].size, memory[i].allocated ? "Yes" : "No");
}
printf("\n");
}
// Function to allocate memory using First Fit algorithm
void firstFit(int size) {
for (int i = 0; i < num_partitions; i++) {
if (!memory[i].allocated && memory[i].size >= size) {
memory[i].allocated = 1;
if (memory[i].size > size) {
memory[num_partitions].start_address = memory[i].start_address + size;
memory[num_partitions].end_address = memory[i].end_address;
memory[num_partitions].size = memory[i].size - size;
memory[num_partitions].allocated = 0;
num_partitions++;
}
memory[i].size = size;
printf("Memory allocated using First Fit.\n");
return;
}
}
printf("Memory allocation failed using First Fit.\n");
}
int main() {
int size;
initializeMemory();
printf("Enter memory size to allocate: ");
scanf("%d", &size);
firstFit(size);
displayMemory();
return 0;
}
Output:-
b. Best Fit:-
Code:-
#include <stdio.h>
#define MEMORY_SIZE 100
#define MAX_PARTITIONS 10
typedef struct {
int start_address;
int end_address;
int size;
int allocated;
} Partition;
Partition memory[MAX_PARTITIONS];
int num_partitions = 0;
// Function to initialize memory
void initializeMemory() {
memory[0].start_address = 0;
memory[0].end_address = MEMORY_SIZE - 1;
memory[0].size = MEMORY_SIZE;
memory[0].allocated = 0;
num_partitions = 1;
}
// Function to display memory
void displayMemory() {
printf("Memory Layout:\n");
printf("Start Address\tEnd Address\tSize\tAllocated\n");
for (int i = 0; i < num_partitions; i++) {
printf("%d\t\t%d\t\t%d\t%s\n", memory[i].start_address, memory[i].end_address,
memory[i].size, memory[i].allocated ? "Yes" : "No");
}
printf("\n");
}
// Function to allocate memory using Best Fit algorithm
void bestFit(int size) {
int best_fit_index = -1;
int min_fragmentation = MEMORY_SIZE + 1;
for (int i = 0; i < num_partitions; i++) {
if (!memory[i].allocated && memory[i].size >= size) {
int fragmentation = memory[i].size - size;
if (fragmentation < min_fragmentation) {
min_fragmentation = fragmentation;
best_fit_index = i;
}
}
}
if (best_fit_index != -1) {
memory[best_fit_index].allocated = 1;
if (memory[best_fit_index].size > size) {
memory[num_partitions].start_address = memory[best_fit_index].start_address + size;
memory[num_partitions].end_address = memory[best_fit_index].end_address;
memory[num_partitions].size = memory[best_fit_index].size - size;
memory[num_partitions].allocated = 0;
num_partitions++;
}
memory[best_fit_index].size = size;
printf("Memory allocated using Best Fit.\n");
} else {
printf("Memory allocation failed using Best Fit.\n");
}
}
int main() {
int size;
initializeMemory();
printf("Enter memory size to allocate: ");
scanf("%d", &size);
bestFit(size);
displayMemory();
return 0;
}
Output:-
Worst Fit:-
Code:-
#include <stdio.h>
#define MEMORY_SIZE 100
#define MAX_PARTITIONS 10
typedef struct {
int start_address;
int end_address;
int size;
int allocated;
} Partition;
Partition memory[MAX_PARTITIONS];
int num_partitions = 0;
// Function to initialize memory
void initializeMemory() {
memory[0].start_address = 0;
memory[0].end_address = MEMORY_SIZE - 1;
memory[0].size = MEMORY_SIZE;
memory[0].allocated = 0;
num_partitions = 1;
}
// Function to display memory
void displayMemory() {
printf("Memory Layout:\n");
printf("Start Address\tEnd Address\tSize\tAllocated\n");
for (int i = 0; i < num_partitions; i++) {
printf("%d\t\t%d\t\t%d\t%s\n", memory[i].start_address, memory[i].end_address,
memory[i].size, memory[i].allocated ? "Yes" : "No");
}
printf("\n");
}
// Function to allocate memory using Worst Fit algorithm
void worstFit(int size) {
int worst_fit_index = -1;
int max_fragmentation = -1;
for (int i = 0; i < num_partitions; i++) {
if (!memory[i].allocated && memory[i].size >= size) {
int fragmentation = memory[i].size - size;
if (fragmentation > max_fragmentation) {
max_fragmentation = fragmentation;
worst_fit_index = i;
}
}
}
if (worst_fit_index != -1) {
memory[worst_fit_index].allocated = 1;
if (memory[worst_fit_index].size > size) {
memory[num_partitions].start_address = memory[worst_fit_index].start_address + size;
memory[num_partitions].end_address = memory[worst_fit_index].end_address;
memory[num_partitions].size = memory[worst_fit_index].size - size;
memory[num_partitions].allocated = 0;
num_partitions++;
}
memory[worst_fit_index].size = size;
printf("Memory allocated using Worst Fit.\n");
} else {
printf("Memory allocation failed using Worst Fit.\n");
}
}
int main() {
int size;
initializeMemory();
printf("Enter memory size to allocate: ");
scanf("%d", &size);
worstFit(size);
displayMemory();
return 0;
}
Output:-
Conclusion:-In conclusion, each allocation strategy has its trade-offs in terms of fragmentation and
computational efficiency. The choice of strategy depends on the specific requirements of the
system, such as the expected size distribution of processes and the tolerance for fragmentation.
