feat: Create round-robin CPU scheduling algorithm

Author: Daemon19

cpu_scheduling_algorithms/round_robin_scheduling.cpp

@@ -0,0 +1,132 @@
+#include <iomanip>
+#include <iostream>
+#include <queue>
+#include <set>
+#include <utility>
+#include <vector>
+
+struct Process {
+    uint32_t id;
+    uint32_t arrival_time;
+    uint32_t burst_time;
+};
+
+struct ProcessResult : public Process {
+    uint32_t completion_time;
+    uint32_t turn_around_time;
+    uint32_t waiting_time;
+
+    ProcessResult(const Process& process)
+        : Process{process.id, process.arrival_time, process.burst_time},
+          completion_time{},
+          turn_around_time{},
+          waiting_time{} {}
+};
+
+class RRScheduling {
+ public:
+    RRScheduling(const std::initializer_list<Process>& processes,
+                 uint32_t time_slice)
+        : processes(processes.begin(), processes.end()),
+          time_slice(time_slice) {}
+
+    std::vector<ProcessResult> GetResults() const;
+
+    std::vector<Process> processes;
+    uint32_t time_slice;
+};
+
+std::ostream& operator<<(std::ostream& ostream,
+                         const std::vector<ProcessResult>& results);
+
+int main() {
+    RRScheduling scheduler({{0, 3, 3}, {1, 8, 5}, {2, 5, 4}}, 2);
+    auto results = scheduler.GetResults();
+    std::cout << results;
+    std::getchar();
+    return 0;
+}
+
+bool CompareAT(const Process& p1, const Process& p2) {
+    return p1.arrival_time < p2.arrival_time;
+}
+
+std::vector<ProcessResult> RRScheduling::GetResults() const {
+    std::vector<Process> sorted_processes = processes;
+    std::sort(sorted_processes.begin(), sorted_processes.end(), CompareAT);
+
+    std::queue<std::pair<Process, uint32_t>> schedule;
+    std::set<uint32_t> inserted;
+    std::vector<ProcessResult> results(processes.begin(), processes.end());
+    uint32_t time_elapsed = sorted_processes[0].arrival_time;
+
+    auto PushProcessesInRange = [&](uint32_t start, uint32_t end) {
+        for (size_t i = 0; i < sorted_processes.size(); i++) {
+            auto& p = sorted_processes[i];
+            if (p.arrival_time < start) {
+                continue;
+            }
+            if (p.arrival_time > time_elapsed) {
+                break;
+            }
+            if (inserted.find(p.id) != inserted.end()) {
+                continue;
+            }
+            schedule.emplace(p, p.burst_time);
+            inserted.insert(p.id);
+        }
+    };
+
+    PushProcessesInRange(0, time_elapsed);
+
+    while (!schedule.empty()) {
+        auto current = schedule.front();
+        schedule.pop();
+        uint32_t last_elapsed = time_elapsed;
+
+        if (current.second > time_slice) {
+            current.second -= time_slice;
+            time_elapsed += time_slice;
+
+            PushProcessesInRange(last_elapsed, time_elapsed);
+            schedule.push(current);
+
+            continue;
+        }
+
+        time_elapsed += current.second;
+        PushProcessesInRange(last_elapsed, time_elapsed);
+
+        ProcessResult& result = *std::find_if(
+            results.begin(), results.end(),
+            [&](const Process& p) { return p.id == current.first.id; });
+        result.completion_time = time_elapsed;
+        result.turn_around_time = result.completion_time - result.arrival_time;
+        result.waiting_time = result.turn_around_time - result.burst_time;
+    }
+
+    return results;
+}
+
+std::ostream& operator<<(std::ostream& ostream,
+                         const std::vector<ProcessResult>& results) {
+    std::vector<ProcessResult> sorted(results);
+    std::sort(sorted.begin(), sorted.end(), CompareAT);
+
+    ostream << std::setw(17) << std::left << "Process ID" << std::setw(17)
+            << std::left << "Arrival Time" << std::setw(17) << std::left
+            << "Burst Time" << std::setw(17) << std::left << "Completion Time"
+            << std::setw(17) << std::left << "Turnaround Time" << std::setw(17)
+            << std::left << "Waiting Time" << std::endl;
+
+    for (auto& p : sorted) {
+        ostream << std::setw(17) << std::left << p.id << std::setw(17)
+                << std::left << p.arrival_time << std::setw(17) << std::left
+                << p.burst_time << std::setw(17) << std::left
+                << p.completion_time << std::setw(17) << std::left
+                << p.turn_around_time << std::setw(17) << std::left
+                << p.waiting_time << "\n";
+    }
+
+    return ostream;
+}