In C$++$ Programming, I need help in simulating various CPU scheduling algorithms.

Here's the scheduling algorithms I need to simulate:

$$First$-$Come, First$-$Serve $($FCFS$)$

$$Shortest Job First $($SJF$)$

$$Shortest Remaining Time $($SRT$)$

$$Round Robin $($RR$)$

The Output for each simulated algorithm needs to display the following for each of the above processes:

o Process ID

o Arrival Time

o Burst Time

o Average Waiting Time $($The time a process spends in the ready queue before it starts

execution.$)$

o Average Turnaround Time $($The total time taken for a process to complete from the

time of its arrival.$)$

Output Example

Process $|$ Arrival Time $|$ Burst Time $|$ Waiting Time $|$ Turnaround Time

P$1|0|8|0|8$

P$2|1|4|7|11$

P$3|2|9|10|19$

P$4|3|5|18|23$

Average Waiting Time: $8\mathrm{.}75$

Average Turnaround Time: $15\mathrm{.}25$

Here's what I have so far:

#include

#include

#include

using namespace std;

$//$ Process Definitions

struct Process $\{$

int pid;

int arrival$\_$time;

int burst$\_$time;

int waiting$\_$time;

int turnaround$\_$time;

int remaining$\_$time;

$\}$

Process$($int id$,$ int at$,$ int bt$)\{$

pid $=$ id;

arrival$\_$time $=$ at;

burst$\_$time $=$ bt;

waiting$\_$time $=0$;

turnaround$\_$time $=0$;

remaining$\_$time $=$ bt;

$\}$

$\}$;

$//$ input data

vector processes $=\{$

Process$(1,0,8),$

Process$(2,1,4),$

Process$(3,2,9),$

Process$(4,3,5)$

$\}$;

$//$ Scheduling Algorithms:

$//$ First$-$Come, First$-$Serve $($FCFS$)$

void fcfs$\_$scheduling$($vector& processes$)\{$

sort$($processes$.$begin$(),$ processes.end$(),[]($Process a$,$ Process b$)\{$

return a$.$arrival$\_$time $<$ b$.$arrival$\_$time;

$\})$;

int current$\_$time $=0$;

for $($auto& process : processes$)\{$

if $($current$\_$time $<$ process.arrival$\_$time$)\{$

current$\_$time $=$ process.arrival$\_$time;

$\}$

process.waiting$\_$time $=$ current$\_$time $-$ process.arrival$\_$time;

process.turnaround$\_$time $=$ process.waiting$\_$time $+$

process.burst$\_$time;

current$\_$time $+=$ process.burst$\_$time;

$\}$

$\}$

$//$ Shortest Job First $($SJF$)$

void sjf$\_$scheduling$($vector& processes$)\{$

$//$ Sort processes based on arrival time, then burst time

sort$($processes$.$begin$(),$ processes.end$(),[]($Process& a$,$

Process& b$)\{$

return $($a$.$arrival$\_$time $==$ b$.$arrival$\_$time$)?$ a$.$burst$\_$time $<$

b$.$burst$\_$time : a$.$arrival$\_$time $<$ b$.$arrival$\_$time;

$\})$;

int current$\_$time $=0$;

vector ready$\_$queue;

vector completed$\_$processes;

$//$ Add processes to ready queue and select the shortest job

$//$ Execute the shortest job and continue the loop

$\}$

$//$ Shortest Remaining Time $($SRT$)$

void srt$\_$scheduling$($vector& processes$)\{$

int current$\_$time $=0$;

vector ready$\_$queue;

$//$ Continue to pick processes based on remaining time

$//$ Preempt the process when needed and update the

remaining time

$\}$

$//$ Round Robin $($RR$)$

void round$\_$robin$\_$scheduling$($vector& processes, int

time$\_$quantum$)\{$

int current$\_$time $=0$;

vector ready$\_$queue;

$//$ Loop through processes, run for the time quantum, and

rotate

$\}$

$//$ Display Output

void display$\_$results$($const string& algorithm$\_$name, const

vector& processes$)\{$

cout $<<$ "Results for $"<<$ algorithm$\_$name $<<"$:$"<<$ endl;

$//$ Display results

for $($const auto& process : processes$)\{$

cout $<<$ "Process ID: $"<<$ process.pid $<<",$ Arrival Time: $"<<$

process.arrival$\_$time $<<",$ Burst Time: $"<<$ process.burst$\_$time $<<",$ Waiting Time:

$"<<$ process.waiting$\_$time

$<<",$ Turnaround Time: $"<<$ process.turnaround$\_$time $<<$

endl;

$\}$

$//$ Calculate and display the average waiting and turnaround

times $($to be implemented$)$

$\}$