From cac03a91a58a5b2ce0306d46c829d022180bde61 Mon Sep 17 00:00:00 2001 From: rhinemann Date: Tue, 1 Apr 2025 20:17:08 +0300 Subject: [PATCH] Added the working set, broke the program, segfault. --- Kernel.cpp | 17 +++++++++++------ Kernel.h | 1 - Process.cpp | 18 ++++++++++++++---- Process.h | 13 ++++++------- main.cpp | 36 ++++++++++++++++++++++++++---------- 5 files changed, 57 insertions(+), 28 deletions(-) diff --git a/Kernel.cpp b/Kernel.cpp index ae34101..5164f68 100644 --- a/Kernel.cpp +++ b/Kernel.cpp @@ -4,8 +4,8 @@ using std::next; -Kernel::Kernel(const unsigned int RunQ_max_length, const List &free_pages, const List &busy_pages) -: free_pages(free_pages), busy_pages(busy_pages), swapped_page(nullptr) { +Kernel::Kernel(const unsigned int RunQ_max_length, const List &free_pages, + const List &busy_pages) : free_pages(free_pages), busy_pages(busy_pages) { RunQ.reserve(RunQ_max_length); } @@ -18,20 +18,24 @@ void Kernel::page_fault(std::vector *page_table, const unsigned int idx) { free_pages.remove(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 { std::cout << "[kernel:page_fault] No free pages available, trying to swap..." << std::endl; for (PhysicalPage *curr = busy_pages.get_head();; curr = curr->next) { if ((*curr->PT)[curr->idx].R) (*curr->PT)[curr->idx].R = false; 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; 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; } } @@ -54,4 +58,5 @@ void Kernel::stat_update() { std::cout << std::format("[kernel:update_job] Updating ppn {} status", curr->PPN) << std::endl; } } + busy_pages.set_head(curr); } diff --git a/Kernel.h b/Kernel.h index 6b47396..6e1debc 100644 --- a/Kernel.h +++ b/Kernel.h @@ -11,7 +11,6 @@ class Kernel { public: List free_pages, busy_pages; - PhysicalPage *swapped_page; std::vector RunQ; Kernel(unsigned int RunQ_max_length, const List &free_pages, const List &busy_pages); void page_fault(std::vector *page_table, unsigned int idx); diff --git a/Process.cpp b/Process.cpp index 8f110d3..fd92139 100644 --- a/Process.cpp +++ b/Process.cpp @@ -1,11 +1,21 @@ #include "Process.h" +#include +#include +#include #include -Process::Process(const unsigned int id, std::vector pageTable, const unsigned int executionTime) -: pageTable(std::move(pageTable)), executionTime(executionTime), id(id) { +Process::Process(const unsigned int id, std::vector page_table, const unsigned int execution_time, const unsigned int working_set_size) +: page_table(std::move(page_table)), execution_time(execution_time), id(id) { + std::random_device rd; + std::mt19937 gen(rd()); + std::uniform_int_distribution 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 { - return elapsedTime >= executionTime; +bool Process::is_finished(const unsigned int elapsed_time) const { + return elapsed_time >= execution_time; } diff --git a/Process.h b/Process.h index f87a440..d86dfa6 100644 --- a/Process.h +++ b/Process.h @@ -4,13 +4,12 @@ #include "PageTable.h" class Process { - public: - std::vector pageTable; - unsigned int executionTime, id; - Process(unsigned int id, std::vector pageTable, unsigned int executionTime); - [[nodiscard]] bool is_finished(unsigned int elapsedTime) const; +public: + std::vector page_table; + std::vector working_set; + unsigned int execution_time, id; + Process(unsigned int id, std::vector page_table, unsigned int execution_time, unsigned int working_set_size); + [[nodiscard]] bool is_finished(unsigned int elapsed_time) const; }; - - #endif //PROCESS_H diff --git a/main.cpp b/main.cpp index 4094f32..0c590dd 100644 --- a/main.cpp +++ b/main.cpp @@ -7,6 +7,7 @@ static int MAX_PROC = 10; static int PAGE_N = 100; static int PROC_CREATION_INTERVAL = 100; +static int WORKING_SET_SIZE = 15; int main() { std::random_device rd; @@ -21,19 +22,31 @@ int main() { } 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()) { break; } - std::uniform_int_distribution index_distribution(0, kernel.RunQ.at(0).pageTable.size() - 1); + std::uniform_int_distribution index_distribution; for (int j = 0; j < 30; ++j) { - const AccessType 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); + const AccessType access_type = access_type_distr(gen) == 1 ? WRITE : READ; + + if (access_type_distr(gen) == 1) { + index_distribution = std::uniform_int_distribution(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(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; @@ -41,8 +54,8 @@ int main() { kernel.stat_update(); - if (kernel.RunQ.at(0).is_finished(elapsed_time)) { - std::cout << std::format("[kernel:remove_current_process] Cleaning up process id {}", kernel.RunQ.at(0).id) << std::endl; + 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(process_index).id) << std::endl; PhysicalPage *curr, *cached_next; unsigned int j; @@ -51,17 +64,20 @@ int main() { curr && j < cached_len; curr = cached_next, ++j) { 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; kernel.busy_pages.remove(curr); + + curr->PT = nullptr; + kernel.free_pages.insert_tail(curr); } } kernel.RunQ.erase(kernel.RunQ.begin()); 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_proc_time = 0; }