doc: add doxygen documentation to round_robin_scheduling.cpp

Author: Daemon19

cpu_scheduling_algorithms/round_robin_scheduling.cpp

@@ -1,3 +1,14 @@
+/**
+ * @file
+ * @brief Implementation of Round Robin CPU scheduling algorithm
+ * @details
+ * Round-robin is a preemptive CPU scheduling algorithm where each
+ * ready task runs turn by turn only in a cyclic queue for a limited
+ * time slice. This algorithm also offers starvation free execution
+ * of processes.
+ * @author [Daemon19](https://github.com/Daemon19)
+ */
+
 #include <iomanip>
 #include <cassert>
 #include <string>
@@ -7,23 +18,43 @@
 #include <utility>
 #include <vector>
 
+/**
+ * @brief Represent a process to be executed.
+ */
 struct Process {
     uint32_t id;
     uint32_t arrival_time;
     uint32_t burst_time;
 };
 
+/**
+ * @brief Represent the result of a process execution.
+ */
 struct ProcessResult : public Process {
     uint32_t completion_time;
     uint32_t turn_around_time;
     uint32_t waiting_time;
 
+    /**
+     * @brief Constructor that calculate member variables based on a
+     * process and completion time.
+     * 
+     * \param process A process that have been executed
+     * \param completion_time The process execution finish time
+     */
     ProcessResult(const Process& process, uint32_t completion_time)
         : Process(process), completion_time(completion_time) {
         turn_around_time = completion_time - arrival_time;
         waiting_time = turn_around_time - burst_time;
     }
 
+    /**
+     * @brief Compare each member variable.
+     * 
+     * \param p ProcessResult to be compared with
+     * \return true if the processes IS equal
+     * \return false if the processes IS NOT equal
+     */
     bool operator==(const ProcessResult& p) const {
         return id == p.id && arrival_time == p.arrival_time &&
                burst_time == p.burst_time &&
@@ -33,16 +64,65 @@ struct ProcessResult : public Process {
     }
 };
 
+/**
+ * @brief Execute processes based on Round-robin algorithm.
+ * 
+ * \param processes Processes to be executed
+ * \param time_slice Time slice for processes execution
+ * \return Results of each process execution
+ */
 std::vector<ProcessResult> RRExecute(const std::vector<Process>& processes,
                                      uint32_t time_slice);
+
+/**
+ * @brief Print a table containing process results data.
+ * 
+ * \return ostream inputted ostream
+ */
 std::ostream& operator<<(std::ostream& ostream,
                          const std::vector<ProcessResult>& results);
+
+/**
+ * @brief Self-test implementations.
+ * 
+ * \returns void
+ */
 void Test();
 
+
+/**
+ * @brief Comparator function for sorting processes.
+ * 
+ * \param p1 Process to be compared
+ * \param p2 Process to be compared
+ * \return 
+ */
 bool CompareAT(const Process& p1, const Process& p2) {
     return p1.arrival_time < p2.arrival_time;
 }
 
+/**
+ * @brief Check processes that arrive after the given time_elapsed.
+ *
+ * If a process arrive after the give time_elapsed, then the process
+ * will be pushed into the schedule queue and inserted into the
+ * arrived_process set.
+ * 
+ * \param processes Processes that will be checked for arrival
+ * \param arrived_process A set containing processes that has arrived
+ * \param schedule Queue containing pair of process and its remaining burst time
+ * \param time_elapsed Time that has elapsed after processes execution
+ */
+void CheckArriveProcess(const std::vector<Process>& processes,
+                        std::set<uint32_t>& arrived_process,
+                        std::queue<std::pair<Process, uint32_t>>& schedule,
+                        uint32_t time_elapsed);
+
+/**
+ * @brief Entry point of the program.
+ * 
+ * \return 0 on exit
+ */
 int main() {
     Test();
     return 0;
@@ -68,11 +148,6 @@ void Test() {
     std::cout << "All test passed";
 }
 
-void CheckArriveProcess(const std::vector<Process>& processes,
-                        std::set<uint32_t>& arrived_process,
-                        std::queue<std::pair<Process, uint32_t>>& schedule,
-                        uint32_t time_elapsed);
-
 std::vector<ProcessResult> RRExecute(const std::vector<Process>& processes,
                                      uint32_t time_slice) {
     std::vector<Process> sorted_processes = processes;