CPU SCHEDULING CODES:

1] FCFS/FIFO:
#include <iostream>
#include <vector>
using namespace std;

struct Process {
int id; // Process ID
int AT; // Arrival Time
int BT; // Burst Time
int CT; // Completion Time
int TAT; // Turnaround Time
int WT; // Waiting Time
};

int main() {
int n;
cout << "Enter the number of processes: ";
cin >> n;
cout << endl;

vector<Process> processes(n);

// Input arrival and burst times

cout << "Enter arrival time and burst time for processes\n";
for (int i = 0; i < n; i++) {
processes[i].id = i + 1;
 cout << "Process " << i + 1 << " arrival time: ";
cin >> processes[i].AT;
cout << "Process " << i + 1 << " burst time: ";
cin >> processes[i].BT;
}

// Sort processes by Arrival Time

for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
if (processes[i].AT > processes[j].AT) {
swap(processes[i], processes[j]);
}
}
}

// Calculate Completion Time (CT), Turnaround Time (TAT),

and Waiting Time (WT)
int currentTime = 0;
for (int i = 0; i < n; i++) {
if (currentTime < processes[i].AT) {
currentTime = processes[i].AT; // CPU becomes idle
}
processes[i].CT = currentTime + processes[i].BT;
currentTime = processes[i].CT;

processes[i].TAT = processes[i].CT - processes[i].AT; //

Turnaround Time
 processes[i].WT = processes[i].TAT - processes[i].BT; //
Waiting Time
}

// Calculate average TAT and WT

double avgTAT = 0, avgWT = 0;
for (int i = 0; i < n; i++) {
avgTAT += processes[i].TAT;
avgWT += processes[i].WT;
}
avgTAT /= n;
avgWT /= n;

// Display results
cout << "\nP | AT | BT | CT | TAT | WT |\n";
for (int i = 0; i < n; i++) {
cout << " " << processes[i].id << " | " << processes[i].AT
<< " | "
<< processes[i].BT << " | " << processes[i].CT << " | "
<< processes[i].TAT << " | " << processes[i].WT << "
|\n";
}

cout << "\nAverage Turnaround Time (TAT): " << avgTAT <<
endl;
cout << "Average Waiting Time (WT): " << avgWT << endl;

return 0;
}

2] SJF

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;

// Structure to represent each process

struct Process {
int id;
int arrivalTime;
int burstTime;
int completionTime;
int turnaroundTime;
int waitingTime;
};

int main() {
int n;

// Input the number of processes

cout << "Enter the number of processes: ";
cin >> n;
 vector<Process> processes(n);

// Input arrival time and burst time for each process

cout << "Enter arrival time and burst time for each process:\
n";
for (int i = 0; i < n; i++) {
processes[i].id = i + 1; // Process ID starts from 1
cout << "Process " << i + 1 << " Arrival Time: ";
cin >> processes[i].arrivalTime;
cout << "Process " << i + 1 << " Burst Time: ";
cin >> processes[i].burstTime;
}

// Sort processes by arrival time first, then by burst time for

SJF
sort(processes.begin(), processes.end(), [](Process a, Process
b) {
if (a.arrivalTime == b.arrivalTime) {
return a.burstTime < b.burstTime;
}
return a.arrivalTime < b.arrivalTime;
});

int currentTime = 0;
vector<bool> isCompleted(n, false); // Track completed
processes

// Calculate Completion Time (CT), Turnaround Time (TAT),

and Waiting Time (WT)
 for (int i = 0; i < n; i++) {
int idx = -1;
int minBurstTime = INT_MAX;

// Select the process with the smallest burst time that has
arrived and not yet completed
for (int j = 0; j < n; j++) {
if (!isCompleted[j] && processes[j].arrivalTime <=
currentTime && processes[j].burstTime < minBurstTime) {
minBurstTime = processes[j].burstTime;
idx = j;
}
}

if (idx == -1) {
// No process has arrived yet; advance current time to
the next process's arrival time
for (int j = 0; j < n; j++) {
if (!isCompleted[j]) {
currentTime = processes[j].arrivalTime;
break;
}
}
i--; // Revisit this iteration to find the next process
} else {
// Process found
isCompleted[idx] = true;
currentTime += processes[idx].burstTime;
 processes[idx].completionTime = currentTime;
processes[idx].turnaroundTime =
processes[idx].completionTime - processes[idx].arrivalTime;
processes[idx].waitingTime =
processes[idx].turnaroundTime - processes[idx].burstTime;
}
}

// Calculate average Turnaround Time and Waiting Time

double avgTAT = 0, avgWT = 0;
for (int i = 0; i < n; i++) {
avgTAT += processes[i].turnaroundTime;
avgWT += processes[i].waitingTime;
}

avgTAT /= n;
avgWT /= n;

// Output the results

cout << "\nProcess ID | Arrival Time | Burst Time |
Completion Time | Turnaround Time | Waiting Time\n";
for (int i = 0; i < n; i++) {
cout << " " << processes[i].id << " | " <<
processes[i].arrivalTime
<< " | " << processes[i].burstTime
<< " | " << processes[i].completionTime
<< " | " << processes[i].turnaroundTime
<< " | " << processes[i].waitingTime << endl;
 }

cout << "\nAverage Turnaround Time: " << avgTAT << endl;
cout << "Average Waiting Time: " << avgWT << endl;

return 0;
}

3] RR scheduling:
#include<iostream>
#include<iomanip>
using namespace std;
int main(){
int n,quantum,completed=0,total_time=0;
double avg_tat=0,avg_wt=0;
cout<<"Enter the number of processes: ";
cin>>n;
cout<<"Enter the time qunatum: ";
cin>>quantum;
int at[n],bt[n],rem_bt[n],ct[n],tat[n],wt[n];
for(int i=0;i<n;i++){
cout<<"Arrival time for process p"<<i+1<<":";
cin>>at[i];
cout<<"Burst time for process p"<<i+1<<":";
cin>>bt[i];
rem_bt[i]=bt[i];
}
int time=0;
bool done[n] ={false};
//logic
while(completed<n){
bool all_idle=true;
for(int i=0;i<n;i++){
if(rem_bt[i]>0 && at[i]<=time){
all_idle=false;

if(rem_bt[i]>quantum){
time+=quantum;
rem_bt[i]-=quantum;
}
else{
time+=rem_bt[i];
rem_bt[i]=0;
ct[i]=time;
tat[i]=ct[i]-at[i];
wt[i]=tat[i]-bt[i];
avg_tat+=tat[i];
avg_wt+=wt[i];
completed++;
done[i]=true;
}
}
}

if(all_idle){
 time++;
}
}
avg_tat/=n;
avg_wt/=n;
cout<<"\nProcess | AT | BT | CT | TAT | WT |\n";
cout<<fixed<<setprecision(2);
for(int i=0;i<n;i++){
cout<<"P "<<i+1<<" \t"<<at[i]<<"\t\t"<<bt[i]<<"\t\
t"<<ct[i]<<"\t\t"<<tat[i]<<"\t\t"<<wt[i]<<endl;

cout<<"\n Avg TAT: "<<avg_tat<<endl;

cout<<"Avg WT: "<<avg_wt<<endl;
return 0;
}