First commit.

CMakeLists.txt

@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 3.30)
+project(code)
+
+set(CMAKE_CXX_STANDARD 23)
+
+add_executable(code main.cpp
+        List.cpp
+        List.h
+        Kernel.cpp
+        Kernel.h
+        MMU.cpp
+        MMU.h
+        PhysicalPage.cpp
+        PhysicalPage.h
+        PageTable.cpp
+        PageTable.h
+        PTE.cpp
+        PTE.h
+        Process.cpp
+        Process.h)

Kernel.cpp

@@ -0,0 +1,29 @@
+#include "Kernel.h"
+
+Kernel::Kernel(const List<PhysicalPage> &free_pages, const List<PhysicalPage> &busy_pages)
+: free_pages(free_pages), busy_pages(busy_pages) {
+}
+
+
+void Kernel::page_fault(PageTable page_table, const int idx) {
+    PhysicalPage *page;
+    if (!this->free_pages.is_empty()) {
+        page = free_pages.last();
+        free_pages.remove(page);
+        busy_pages.insert_tail(page);
+    } else {
+        page = nullptr; // TODO: page replacement algorithm
+    }
+    if (page) {
+        page_table[idx].PPN = page->PPN;
+        page_table[idx].P = true;
+        page_table[idx].R = false;
+        page_table[idx].M = false;
+    }
+}
+
+void Kernel::stat_update() {
+    for (int i = 0; i < 10; ++i) {
+        // TODO: update busy page stats
+    }
+}

Kernel.h

@@ -0,0 +1,22 @@
+#ifndef KERNEL_H
+#define KERNEL_H
+
+#include <vector>
+
+#include "PhysicalPage.h"
+#include "PageTable.h"
+#include "List.h"
+#include "Process.h"
+
+class Kernel {
+public:
+        List<PhysicalPage> free_pages, busy_pages;
+        // TODO: RunQ
+        std::vector<Process> RunQ;
+        Kernel(const List<PhysicalPage> &free_pages, const List<PhysicalPage> &busy_pages);
+        void page_fault(PageTable page_table, int idx);
+        void stat_update();
+
+};
+
+#endif //KERNEL_H

List.cpp

@@ -0,0 +1 @@
+#include "List.h"

List.h

@@ -0,0 +1,109 @@
+#ifndef LIST_H
+#define LIST_H
+
+template<typename T>
+class List {
+    T *head, *tail;
+    unsigned int num;
+    const unsigned int idx;
+    public:
+        explicit List(unsigned int idx);
+        T *first();
+        T *last();
+        void insert_head(T *elem);
+        void insert_tail(T *elem);
+        void insert_before(T *elem1, T *elem2);
+        void remove(T *elem);
+        bool is_empty();
+        [[nodiscard]] unsigned int get_num() const;
+};
+
+#define for_each_in_list(elem, list)    \
+    for (                               \
+        (elem) = (list)->first();       \
+        (elem) != nullptr;              \
+        (elem) = (list)->next(elem)     \
+    )
+
+template<typename T>
+List<T>::List(const unsigned int idx) : head{nullptr}, tail{nullptr}, num{0}, idx{idx} {
+}
+
+template<typename T>
+T * List<T>::first() {
+    return this->head;
+}
+
+template<typename T>
+T * List<T>::last() {
+    return this->tail;
+}
+
+template<typename T>
+void List<T>::insert_head(T *elem) {
+    const unsigned int idx{this->idx};
+
+    elem->next[idx] = this->head;
+    elem->prev[idx] = nullptr;
+    if (this->head != nullptr)
+        this->head->prev[idx] = elem;
+    if (this->tail == nullptr)
+        this->tail = elem;
+    this->head = elem;
+    ++this->num;
+}
+
+template<typename T>
+void List<T>::insert_tail(T *elem) {
+    const unsigned int idx{this->idx};
+
+    elem->next[idx] = nullptr;
+    elem->prev[idx] = this->tail;
+    if (this->tail != nullptr)
+        this->tail->next[idx] = elem;
+    if (this->head == nullptr)
+        this->head = elem;
+    this->tail = elem;
+    ++this->num;
+}
+
+template<typename T>
+void List<T>::insert_before(T *elem1, T *elem2) {
+    const unsigned int idx{this->idx};
+
+    elem1->next[idx] = elem2;
+    elem1->prev[idx] = elem2->prev[idx];
+    elem2->prev[idx] = elem1;
+    if (elem1->prev[idx] == nullptr)
+        this->head = elem1;
+    else
+        elem1->prev[idx]->next[idx] = elem1;
+    ++this->num;
+}
+
+template<typename T>
+void List<T>::remove(T *elem) {
+    const unsigned int idx{this->idx};
+
+    if (elem->next[idx] != nullptr)
+        elem->next[idx]->prev[idx] = elem->prev[idx];
+    if (elem->prev[idx] != nullptr)
+        elem->prev[idx]->next[idx] = elem->next[idx];
+    if (this->head == elem)
+        this->head = elem->next[idx];
+    if (this->tail == elem)
+        this->tail = elem->prev[idx];
+    --this->num;
+}
+
+template<typename T>
+bool List<T>::is_empty() {
+    return this->num == 0;
+}
+
+template<typename T>
+unsigned int List<T>::get_num() const {
+    return this->num;
+}
+
+#endif //LIST_H

MMU.cpp

@@ -0,0 +1,10 @@
+#include "MMU.h"
+
+void MMU::access(Kernel kernel, PageTable table, const int index, const AccessType type) {
+    if (!table[index].P)
+        kernel.page_fault(table, index);
+    table[index].R = true;
+
+    if (type == WRITE)
+        table[index].M = true;
+}

MMU.h

@@ -0,0 +1,20 @@
+#ifndef MMU_H
+#define MMU_H
+
+#include "Kernel.h"
+#include "PageTable.h"
+
+enum AccessType {
+    READ,
+    WRITE,
+};
+
+class MMU {
+    public:
+        static void access(Kernel kernel, PageTable table, int index, AccessType type);
+        // TODO type of access
+};
+
+
+
+#endif //MMU_H

PTE.cpp

@@ -0,0 +1,5 @@
+//
+// Created by rhinemann on 10.03.25.
+//
+
+#include "PTE.h"

PTE.h

@@ -0,0 +1,14 @@
+//
+// Created by rhinemann on 10.03.25.
+//
+
+#ifndef PTE_H
+#define PTE_H
+
+class PTE {
+    public:
+        bool P, R, M;
+        unsigned int PPN;
+};
+
+#endif //PTE_H

PageTable.cpp

@@ -0,0 +1,5 @@
+#include "PageTable.h"
+
+PTE & PageTable::operator[](const int index) {
+    return this->entries.at(index);
+}

PageTable.h

@@ -0,0 +1,18 @@
+//
+// Created by rhinemann on 10.03.25.
+//
+
+#ifndef PAGETABLE_H
+#define PAGETABLE_H
+
+#include <vector>
+
+#include "PTE.h"
+
+class PageTable {
+    public:
+        std::vector<PTE> entries;
+        PTE &operator[](int index);
+};
+
+#endif //PAGETABLE_H

PhysicalPage.cpp

@@ -0,0 +1,9 @@
+#include "PhysicalPage.h"
+
+PhysicalPage::PhysicalPage(const unsigned int PPN): PPN(PPN) {
+}
+
+void PhysicalPage::take_up(PageTable *PT, const unsigned int idx) {
+    this->idx = idx;
+    this->PT = PT;
+}

PhysicalPage.h

@@ -0,0 +1,21 @@
+//
+// Created by rhinemann on 10.03.25.
+//
+
+#ifndef PHYSICALPAGE_H
+#define PHYSICALPAGE_H
+
+#include "PageTable.h"
+
+class PhysicalPage {
+    public:
+        unsigned int PPN, idx;
+        PageTable *PT;
+        PhysicalPage *next[2], *prev[2];
+
+        explicit PhysicalPage(unsigned int PPN);
+
+        void take_up(PageTable *PT, unsigned int idx);
+};
+
+#endif //PHYSICALPAGE_H

Process.cpp

@@ -0,0 +1,9 @@
+#include "Process.h"
+
+Process::Process(PageTable *pageTable, const unsigned int executionTime)
+: pageTable(pageTable), executionTime(executionTime), elapsedTime(0) {
+}
+
+bool Process::is_finished() {
+    return elapsedTime >= executionTime;
+}

Process.h

@@ -0,0 +1,16 @@
+#ifndef PROCESS_H
+#define PROCESS_H
+
+#include "PageTable.h"
+
+class Process {
+    public:
+        PageTable *pageTable;
+        unsigned int executionTime, elapsedTime;
+        Process(PageTable *pageTable, unsigned int executionTime);
+        bool is_finished();
+};
+
+
+
+#endif //PROCESS_H

main.cpp

@@ -0,0 +1,31 @@
+#include <iostream>
+#include <random>
+
+#include "Kernel.h"
+
+static int MAX_PROC = 10;
+static int PAGE_N = 10;
+
+int main() {
+    std::random_device rd;
+    std::mt19937 gen(rd());
+    std::uniform_int_distribution<unsigned int> distribution(0, 10);
+
+    List<PhysicalPage> free_pages(0), busy_pages(0);
+    Kernel kernel(free_pages, busy_pages);
+
+    for (int i = 0; i < PAGE_N; ++i) {
+        free_pages.insert_tail(new PhysicalPage(i));
+    }
+
+    for (int i = 0; i < MAX_PROC; ++i) {
+        kernel.RunQ.emplace_back(nullptr, distribution(gen));
+    }
+
+    for (const auto process : kernel.RunQ)
+        std::cout << process.executionTime << std::endl;
+
+    // std::cout << MAX_PROC << std::endl;
+
+    return 0;
+}