From daf81a2de719023350b9534dbdb1ecfb9899663a Mon Sep 17 00:00:00 2001 From: rhinemann Date: Tue, 1 Apr 2025 22:06:25 +0300 Subject: [PATCH] Finalised the lab work. --- Kernel.cpp | 6 ++---- Kernel.h | 5 ++--- Process.cpp | 16 ++++++++++++---- Process.h | 13 ++++++++----- main.cpp | 46 +++++++++++++++++++++++++++++----------------- 5 files changed, 53 insertions(+), 33 deletions(-) diff --git a/Kernel.cpp b/Kernel.cpp index ae34101..eed416f 100644 --- a/Kernel.cpp +++ b/Kernel.cpp @@ -4,10 +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) { - RunQ.reserve(RunQ_max_length); -} +Kernel::Kernel(const List &free_pages, const List &busy_pages) +: free_pages(free_pages), busy_pages(busy_pages) {} void Kernel::page_fault(std::vector *page_table, const unsigned int idx) { std::cout << std::format("[kernel:page_fault] Handling {} started", idx) << std::endl; diff --git a/Kernel.h b/Kernel.h index 6b47396..2dc1f55 100644 --- a/Kernel.h +++ b/Kernel.h @@ -11,9 +11,8 @@ 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); + List RunQ; + Kernel(const List &free_pages, const List &busy_pages); void page_fault(std::vector *page_table, unsigned int idx); void stat_update(); diff --git a/Process.cpp b/Process.cpp index 8f110d3..9a6f8f0 100644 --- a/Process.cpp +++ b/Process.cpp @@ -1,11 +1,19 @@ #include "Process.h" +#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 working_set_size, + const unsigned int execution_time) : page_table(std::move(page_table)), execution_time(execution_time), elapsed_time(0), + id(id), next(nullptr), prev(nullptr) { + std::random_device rd; + std::mt19937 gen(rd()); + std::uniform_int_distribution page_table_distribution(0, this->page_table.size() - 1); + for (int i = 0; i < working_set_size; ++i) { + working_set.push_back(page_table_distribution(gen)); + } } -bool Process::is_finished(const unsigned int elapsedTime) const { - return elapsedTime >= executionTime; +bool Process::is_finished() const { + return elapsed_time >= execution_time; } diff --git a/Process.h b/Process.h index f87a440..b422f7b 100644 --- a/Process.h +++ b/Process.h @@ -4,11 +4,14 @@ #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, elapsed_time, id; + Process *next, *prev; + + Process(unsigned int id, std::vector page_table, unsigned int working_set_size, unsigned int execution_time); + [[nodiscard]] bool is_finished() const; }; diff --git a/main.cpp b/main.cpp index 4094f32..a7d37ee 100644 --- a/main.cpp +++ b/main.cpp @@ -7,42 +7,49 @@ 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; std::mt19937 gen(rd()); std::uniform_int_distribution page_table_distribution(500, 1000), lifetime_distribution(50, 500), access_type_distr(1, 10); - Kernel kernel(MAX_PROC, List(), List()); + Kernel kernel = Kernel(List(), List()); unsigned int elapsed_time = 0, new_proc_time = 0, new_ppn; for (new_ppn = 1; new_ppn <= PAGE_N; ++new_ppn) { kernel.free_pages.insert_head(new PhysicalPage(new_ppn)); } - for (int i = 0; i < kernel.RunQ.capacity(); ++i) { - kernel.RunQ.emplace_back(i, std::vector(page_table_distribution(gen), PTE()), lifetime_distribution(gen)); + for (int i = 0; i < MAX_PROC; ++i) { + kernel.RunQ.insert_head(new Process(i, std::vector(page_table_distribution(gen), PTE()), WORKING_SET_SIZE, lifetime_distribution(gen))); } - for (int i = 0; i < 10000; ++i) { - if (kernel.RunQ.empty()) { - break; - } + for (int i = 0; i < 10'000; ++i) { + Process *current_process = kernel.RunQ.get_head(); - 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); + + if (access_type_distr(gen) == 1) { + index_distribution = std::uniform_int_distribution(0, current_process->page_table.size() - 1); + const unsigned int table_index = index_distribution(gen); + MMU::access(kernel, ¤t_process->page_table, table_index, type); + } else { + index_distribution = std::uniform_int_distribution(0, current_process->working_set.size() - 1); + const unsigned int table_index = index_distribution(gen); + MMU::access(kernel, ¤t_process->page_table, current_process->working_set[table_index], type); + } } - ++elapsed_time; + ++current_process->elapsed_time; ++new_proc_time; 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 (current_process->is_finished()) { + std::cout << std::format("[kernel:remove_current_process] Cleaning up process id {}", current_process->id) << std::endl; PhysicalPage *curr, *cached_next; unsigned int j; @@ -51,17 +58,19 @@ 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 == ¤t_process->page_table) { std::cout << std::format("[kernel:remove_current_process] Found ppn #{}, freeing it", curr->PPN) << std::endl; kernel.busy_pages.remove(curr); kernel.free_pages.insert_tail(curr); } } - kernel.RunQ.erase(kernel.RunQ.begin()); + + kernel.RunQ.set_head(current_process->next); + kernel.RunQ.remove(current_process); 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.insert_tail(new Process(new_ppn, std::vector(page_table_distribution(gen), PTE()), WORKING_SET_SIZE, lifetime_distribution(gen))); ++new_ppn; new_proc_time = 0; } @@ -72,10 +81,13 @@ int main() { std::cout << std::format("[main:metrics] Memory usage stats: busy {}, free {}, total {}", busy_stat, free_stat, free_stat + busy_stat) << std::endl; } - if (kernel.RunQ.empty()) { + if (kernel.RunQ.is_empty()) { std::cout << "[main:scheduling] No processes left to execute!" << std::endl; + break; } } + std::cout << "[main:scheduling] Simulation finished." << std::endl; + return 0; }