Rhinemann
/
spz3
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

Added the working set, broke the program, segfault.

This commit is contained in:
rhinemann 2025-04-01 20:17:08 +03:00
parent 2c8bf9b081
commit cac03a91a5
5 changed files with 57 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
Kernel.cpp
View File

@ -4,8 +4,8 @@
using std::next; using std::next;
Kernel::Kernel(const unsigned int RunQ_max_length, const List<PhysicalPage> &free_pages, const List<PhysicalPage> &busy_pages) Kernel::Kernel(const unsigned int RunQ_max_length, const List<PhysicalPage> &free_pages,
: free_pages(free_pages), busy_pages(busy_pages), swapped_page(nullptr) { const List<PhysicalPage> &busy_pages) : free_pages(free_pages), busy_pages(busy_pages) {
RunQ.reserve(RunQ_max_length); RunQ.reserve(RunQ_max_length);
} }
@ -18,20 +18,24 @@ void Kernel::page_fault(std::vector<PTE> *page_table, const unsigned int idx) {
free_pages.remove(page); free_pages.remove(page);
busy_pages.insert_tail(page); busy_pages.insert_tail(page);
std::cout << std::format("[kernel:page_fault:free] Found free page #{}, using it", page->PPN) << std::endl; std::cout << std::format("[kernel:page_fault:free] Found free page #{}, using it",
page->PPN) << std::endl;
} else { } else {
std::cout << "[kernel:page_fault] No free pages available, trying to swap..." << std::endl; std::cout << "[kernel:page_fault] No free pages available, trying to swap..." << std::endl;
for (PhysicalPage *curr = busy_pages.get_head();; curr = curr->next) { for (PhysicalPage *curr = busy_pages.get_head();; curr = curr->next) {
if ((*curr->PT)[curr->idx].R) if ((*curr->PT)[curr->idx].R)
(*curr->PT)[curr->idx].R = false; (*curr->PT)[curr->idx].R = false;
else { else {
std::cout << std::format("[kernel:page_fault:random] Selected physical page #{} for replacement", curr->PPN) << std::endl; std::cout << std::format("[kernel:page_fault:random] Selected physical page #{} for replacement",
curr->PPN) << std::endl;
curr->PT->erase(next(curr->PT->begin(), curr->idx)); // curr->PT->erase(next(curr->PT->begin(), curr->idx));
(*curr->PT)[curr->idx].P = false;
page = curr; page = curr;
busy_pages.set_head(curr->next); busy_pages.set_head(curr->next);
std::cout << std::format("[kernel:page_fault:random] Auto-advanced the list of busy pages to ppn {}", busy_pages.get_head()->PPN) << std::endl; std::cout << std::format("[kernel:page_fault:random] Auto-advanced the list of busy pages to ppn {}",
busy_pages.get_head()->PPN) << std::endl;
break; break;
} }
} }
@ -54,4 +58,5 @@ void Kernel::stat_update() {
std::cout << std::format("[kernel:update_job] Updating ppn {} status", curr->PPN) << std::endl; std::cout << std::format("[kernel:update_job] Updating ppn {} status", curr->PPN) << std::endl;
} }
} }
busy_pages.set_head(curr);
} }

1
Kernel.h
View File

@ -11,7 +11,6 @@
class Kernel { class Kernel {
public: public:
List<PhysicalPage> free_pages, busy_pages; List<PhysicalPage> free_pages, busy_pages;
PhysicalPage *swapped_page;
std::vector<Process> RunQ; std::vector<Process> RunQ;
Kernel(unsigned int RunQ_max_length, const List<PhysicalPage> &free_pages, const List<PhysicalPage> &busy_pages); Kernel(unsigned int RunQ_max_length, const List<PhysicalPage> &free_pages, const List<PhysicalPage> &busy_pages);
void page_fault(std::vector<PTE> *page_table, unsigned int idx); void page_fault(std::vector<PTE> *page_table, unsigned int idx);

18
Process.cpp
View File

@ -1,11 +1,21 @@
#include "Process.h" #include "Process.h"
#include <iostream>
#include <ostream>
#include <random>
#include <utility> #include <utility>
Process::Process(const unsigned int id, std::vector<PTE> pageTable, const unsigned int executionTime) Process::Process(const unsigned int id, std::vector<PTE> page_table, const unsigned int execution_time, const unsigned int working_set_size)
: pageTable(std::move(pageTable)), executionTime(executionTime), id(id) { : page_table(std::move(page_table)), execution_time(execution_time), id(id) {
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<unsigned int> working_set_distribution(0, this->page_table.size() - 1);
std::cout << page_table.size() - 1 << std::endl;
for (int i = 0; i < working_set_size; ++i) {
working_set.push_back(working_set_distribution(gen));
}
} }
bool Process::is_finished(const unsigned int elapsedTime) const { bool Process::is_finished(const unsigned int elapsed_time) const {
return elapsedTime >= executionTime; return elapsed_time >= execution_time;
} }

13
Process.h
View File

@ -4,13 +4,12 @@
#include "PageTable.h" #include "PageTable.h"
class Process { class Process {
public: public:
std::vector<PTE> pageTable; std::vector<PTE> page_table;
unsigned int executionTime, id; std::vector<unsigned int> working_set;
Process(unsigned int id, std::vector<PTE> pageTable, unsigned int executionTime); unsigned int execution_time, id;
[[nodiscard]] bool is_finished(unsigned int elapsedTime) const; Process(unsigned int id, std::vector<PTE> page_table, unsigned int execution_time, unsigned int working_set_size);
[[nodiscard]] bool is_finished(unsigned int elapsed_time) const;
}; };
#endif //PROCESS_H #endif //PROCESS_H

36
main.cpp
View File

@ -7,6 +7,7 @@
static int MAX_PROC = 10; static int MAX_PROC = 10;
static int PAGE_N = 100; static int PAGE_N = 100;
static int PROC_CREATION_INTERVAL = 100; static int PROC_CREATION_INTERVAL = 100;
static int WORKING_SET_SIZE = 15;
int main() { int main() {
std::random_device rd; std::random_device rd;
@ -21,19 +22,31 @@ int main() {
} }
for (int i = 0; i < kernel.RunQ.capacity(); ++i) { for (int i = 0; i < kernel.RunQ.capacity(); ++i) {
kernel.RunQ.emplace_back(i, std::vector(page_table_distribution(gen), PTE()), lifetime_distribution(gen)); kernel.RunQ.emplace_back(i, std::vector(page_table_distribution(gen), PTE()), lifetime_distribution(gen),
WORKING_SET_SIZE);
} }
for (int i = 0; i < 10000; ++i) { for (int i = 0; i < 10'000; ++i) {
const int process_index = i % kernel.RunQ.size();
if (kernel.RunQ.empty()) { if (kernel.RunQ.empty()) {
break; break;
} }
std::uniform_int_distribution<unsigned int> index_distribution(0, kernel.RunQ.at(0).pageTable.size() - 1); std::uniform_int_distribution<unsigned int> index_distribution;
for (int j = 0; j < 30; ++j) { for (int j = 0; j < 30; ++j) {
const AccessType type = access_type_distr(gen) == 1 ? WRITE : READ; const AccessType access_type = access_type_distr(gen) == 1 ? WRITE : READ;
const unsigned int index = index_distribution(gen);
MMU::access(kernel, &kernel.RunQ.at(0).pageTable, index, type); if (access_type_distr(gen) == 1) {
index_distribution = std::uniform_int_distribution<unsigned int>(0, kernel.RunQ.at(process_index).page_table.size() - 1);
const unsigned int table_index = index_distribution(gen);
MMU::access(kernel, &kernel.RunQ.at(process_index).page_table, table_index, access_type);
}
else {
index_distribution = std::uniform_int_distribution<unsigned int>(0, kernel.RunQ.at(process_index).working_set.size() - 1);
const unsigned int table_index = kernel.RunQ.at(process_index).working_set[index_distribution(gen)];
MMU::access(kernel, &kernel.RunQ.at(process_index).page_table, table_index, access_type);
}
} }
++elapsed_time; ++elapsed_time;
@ -41,8 +54,8 @@ int main() {
kernel.stat_update(); kernel.stat_update();
if (kernel.RunQ.at(0).is_finished(elapsed_time)) { if (kernel.RunQ.at(process_index).is_finished(elapsed_time)) {
std::cout << std::format("[kernel:remove_current_process] Cleaning up process id {}", kernel.RunQ.at(0).id) << std::endl; std::cout << std::format("[kernel:remove_current_process] Cleaning up process id {}", kernel.RunQ.at(process_index).id) << std::endl;
PhysicalPage *curr, *cached_next; PhysicalPage *curr, *cached_next;
unsigned int j; unsigned int j;
@ -51,17 +64,20 @@ int main() {
curr && j < cached_len; curr && j < cached_len;
curr = cached_next, ++j) { curr = cached_next, ++j) {
cached_next = curr->next; cached_next = curr->next;
if (curr->PT == &kernel.RunQ.at(0).pageTable) { if (curr->PT == &kernel.RunQ.at(process_index).page_table) {
std::cout << std::format("[kernel:remove_current_process] Found ppn #{}, freeing it", curr->PPN) << std::endl; std::cout << std::format("[kernel:remove_current_process] Found ppn #{}, freeing it", curr->PPN) << std::endl;
kernel.busy_pages.remove(curr); kernel.busy_pages.remove(curr);
curr->PT = nullptr;
kernel.free_pages.insert_tail(curr); kernel.free_pages.insert_tail(curr);
} }
} }
kernel.RunQ.erase(kernel.RunQ.begin()); kernel.RunQ.erase(kernel.RunQ.begin());
if (new_proc_time >= PROC_CREATION_INTERVAL) { if (new_proc_time >= PROC_CREATION_INTERVAL) {
kernel.RunQ.emplace_back(new_ppn, std::vector(page_table_distribution(gen), PTE()), lifetime_distribution(gen)); kernel.RunQ.emplace_back(new_ppn, std::vector(page_table_distribution(gen), PTE()), lifetime_distribution(gen), WORKING_SET_SIZE);
++new_ppn; ++new_ppn;
new_proc_time = 0; new_proc_time = 0;
} }