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;
Kernel::Kernel(const unsigned int RunQ_max_length, const List<PhysicalPage> &free_pages, const List<PhysicalPage> &busy_pages)
: free_pages(free_pages), busy_pages(busy_pages), swapped_page(nullptr) {
Kernel::Kernel(const unsigned int RunQ_max_length, const List<PhysicalPage> &free_pages,
const List<PhysicalPage> &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<PTE> *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);
}

1
Kernel.h
View File

@ -11,7 +11,6 @@
class Kernel {
public:
List<PhysicalPage> free_pages, busy_pages;
PhysicalPage *swapped_page;
std::vector<Process> RunQ;
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);

18
Process.cpp
View File

@ -1,11 +1,21 @@
#include "Process.h"
#include <iostream>
#include <ostream>
#include <random>
#include <utility>
Process::Process(const unsigned int id, std::vector<PTE> pageTable, const unsigned int executionTime)
: pageTable(std::move(pageTable)), executionTime(executionTime), id(id) {
Process::Process(const unsigned int id, std::vector<PTE> 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<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 {
return elapsedTime >= executionTime;
bool Process::is_finished(const unsigned int elapsed_time) const {
return elapsed_time >= execution_time;
}

13
Process.h
View File

@ -4,13 +4,12 @@
#include "PageTable.h"
class Process {
public:
std::vector<PTE> pageTable;
unsigned int executionTime, id;
Process(unsigned int id, std::vector<PTE> pageTable, unsigned int executionTime);
[[nodiscard]] bool is_finished(unsigned int elapsedTime) const;
public:
std::vector<PTE> page_table;
std::vector<unsigned int> working_set;
unsigned int execution_time, id;
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

36
main.cpp
View File

@ -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<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) {
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<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;
@ -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;
}