Memory Management

CHU2

Jan 19th, 2025 (edited)

Never

Add comment

Not a member of Pastebin yet? Sign Up, it unlocks many cool features!

C++ 4.54 KB | Source Code | 0 0

raw download clone embed print report

#include <iostream>
#include <iomanip> // header to control printing output
using namespace std;
struct block { // memory block
int size;
bool is_allocated;
};
struct process { // processess block
int size;
int allocated_in;
};
void first_fit(block[], int, process[], int);
void best_fit(block[], int, process[], int);
void worst_fit(block[], int, process[], int);
void print(block[], process[], int);
int main() {
const int max_blocks = 10; // max blocks and processes
const int max_processes = 10;
block blocks[max_blocks] = {{100, false}, {500, false}, {200, false}, {300, false}, {600, false}}; // values to be processed
process processes[max_processes] = {{212, -1}, {417, -1}, {112, -1}, {426, -1}};
int block_count = 5, process_count = 4; // size of chuchu
cout << "Blocks: ";
for (int h = 0; h < block_count; h++) {
cout << setw(9) << blocks[h].size;
}
cout << "\nProcessess: ";
cout << setw(5);
for (int h = 0; h < block_count; h++) {
cout << processes[h].size << setw(9);
}
cout << "\nFirst Fit Allocation:\n";
first_fit(blocks, block_count, processes, process_count);
print(blocks, processes, process_count);
for (int h = 0; h < block_count; h++) { // restarts the memory block usage allocation before continuing to another allocation
blocks[h].is_allocated = false;
}
cout << "\nBest Fit Allocation:\n";
best_fit(blocks, block_count, processes, process_count);
print(blocks, processes, process_count);
for (int h = 0; h < block_count; h++) {
blocks[h].is_allocated = false;
}
cout << "\nWorst Fit Allocation:\n";
worst_fit(blocks, block_count, processes, process_count);
print(blocks, processes, process_count);
return 0;
}
void first_fit(block blocks[], int block_count, process processes[], int process_count) {
for (int h = 0; h < process_count; h++) {
processes[h].allocated_in = -1;
for (int i = 0; i < block_count; i++) {
if (!blocks[i].is_allocated && blocks[i].size >= processes[h].size) { // is like linear search
processes[h].allocated_in = i;
blocks[i].is_allocated = true;
break;
}
}
}
}
void best_fit(block blocks[], int block_count, process processes[], int process_count) {
for (int h = 0; h < process_count; h++) {
int best_index = -1;
for (int i = 0; i < block_count; i++) {
if (!blocks[i].is_allocated && blocks[i].size >= processes[h].size) {
if (best_index == -1 || blocks[i].size < blocks[best_index].size) { // finds the best index first before allocating value
best_index = i;
}
}
}
if (best_index != -1) {
processes[h].allocated_in = best_index;
blocks[best_index].is_allocated = true;
} else {
processes[h].allocated_in = -1;
}
}
}
void worst_fit(block blocks[], int block_count, process processes[], int process_count) {
for (int h = 0; h < process_count; h++) {
int worst_index = -1;
for (int i = 0; i < block_count; i++) {
if (!blocks[i].is_allocated && blocks[i].size >= processes[h].size) {
if (worst_index == -1 || blocks[i].size > blocks[worst_index].size) { // same as best_fit but this use > condition in finding the n_fit to ensure it is the highest value available
worst_index = i;
}
}
}
if (worst_index != -1) {
processes[h].allocated_in = worst_index;
blocks[worst_index].is_allocated = true;
} else {
processes[h].allocated_in = -1;
}
}
}
void print(block blocks[], process processes[], int process_count) {
cout << "Process No." << setw(15) << "Process Size" << setw(15) << "Block No." << setw(15) << "Block Size\n"; // setw() is for setting width size
for (int h = 0; h < process_count; h++) { // I use this instead of \t
cout << h + 1 << setw(16) << processes[h].size << setw(24);
if (processes[h].allocated_in != -1) {
cout << processes[h].allocated_in + 1;
}
else {
cout << "Not Allocated";
}
cout << setw(14) << blocks[processes[h].allocated_in].size << "\n";
}
}

Add Comment

Please, Sign In to add comment