OPERATING SYSTEM
ASSIGNMENT
NIT KURUKSHETRA
NAME : NASIB
ROLL NO : 123103058
BRANCH : IT – A
SECTION : 04
Question 1: FCFS
#include<iostream>
using namespace std;
struct Process {
int id, arrivalTime, burstTime, waitingTime, turnaroundTime,
completionTime;
};
void findCompletionTime(Process p[], int n) {
p[0].completionTime = p[0].arrivalTime + p[0].burstTime;
for(int i = 1; i < n; i++) {
if (p[i].arrivalTime > p[i-1].completionTime) {
p[i].completionTime = p[i].arrivalTime + p[i].burstTime;
} else {
p[i].completionTime = p[i-1].completionTime + p[i].burstTime;
}
}
}
void findWaitingTime(Process p[], int n) {
for(int i = 0; i < n; i++) {
p[i].waitingTime = p[i].completionTime - p[i].arrivalTime -
p[i].burstTime;
if(p[i].waitingTime < 0) p[i].waitingTime = 0;
}
}
void findTurnaroundTime(Process p[], int n) {
for(int i = 0; i < n; i++) {
p[i].turnaroundTime = p[i].completionTime - p[i].arrivalTime;
}
}
void findAverageTime(Process p[], int n) {
findCompletionTime(p, n);
findWaitingTime(p, n);
findTurnaroundTime(p, n);
float totalWaitingTime = 0, totalTurnaroundTime = 0;
cout << "\nProcess\tAT\tBT\tCT\tWT\tTAT\n";
for (int i = 0; i < n; i++) {
totalWaitingTime += p[i].waitingTime;
totalTurnaroundTime += p[i].turnaroundTime;
cout << p[i].id << "\t"
<< p[i].arrivalTime << "\t"
<< p[i].burstTime << "\t"
<< p[i].completionTime << "\t"
<< p[i].waitingTime << "\t"
<< p[i].turnaroundTime << "\n";
}
cout << "\nAverage Waiting Time: " << (totalWaitingTime / n);
cout << "\nAverage Turnaround Time: " << (totalTurnaroundTime / n) <<
endl;
}
int main() {
int n;
cout << "Enter number of processes: ";
cin >> n;
Process p[n];
cout << "Enter arrival time and burst time for each process:\n";
for (int i = 0; i < n; i++) {
p[i].id = i + 1;
cout << "Process " << i + 1 << ": ";
cin >> p[i].arrivalTime >> p[i].burstTime;
}
findAverageTime(p, n);
return 0;
}
Output:
Question 2: SJF
#include <iostream>
#include <algorithm>
using namespace std;
struct Process {
int id, arrivalTime, burstTime, waitingTime, turnaroundTime,
completionTime;
};
// Function to sort processes by Arrival Time (Tie-breaker: Burst Time)
bool compare(Process a, Process b) {
if (a.arrivalTime == b.arrivalTime)
return a.burstTime < b.burstTime;
return a.arrivalTime < b.arrivalTime;
}
void findCompletionTime(Process p[], int n) {
sort(p, p + n, compare); // Sort by Arrival Time (Primary), Burst Time
(Secondary)
bool completed[n] = {false};
int completedCount = 0, currentTime = 0;
while (completedCount < n) {
int shortestJob = -1;
int minBurstTime = 1e9;
// Find the process with the shortest burst time that has arrived
for (int i = 0; i < n; i++) {
if (!completed[i] && p[i].arrivalTime <= currentTime &&
p[i].burstTime < minBurstTime) {
shortestJob = i;
minBurstTime = p[i].burstTime;
}
}
if (shortestJob == -1) {
currentTime++; // If no process is available, move time forward
} else {
currentTime += p[shortestJob].burstTime;
p[shortestJob].completionTime = currentTime;
completed[shortestJob] = true;
completedCount++;
}
}
}
void findWaitingTime(Process p[], int n) {
for (int i = 0; i < n; i++) {
p[i].waitingTime = p[i].completionTime - p[i].arrivalTime -
p[i].burstTime;
if (p[i].waitingTime < 0) p[i].waitingTime = 0;
}
}
void findTurnaroundTime(Process p[], int n) {
for (int i = 0; i < n; i++) {
p[i].turnaroundTime = p[i].completionTime - p[i].arrivalTime;
}
}
void findAverageTime(Process p[], int n) {
findCompletionTime(p, n);
findWaitingTime(p, n);
findTurnaroundTime(p, n);
float totalWaitingTime = 0, totalTurnaroundTime = 0;
cout << "\nProcess\tAT\tBT\tCT\tWT\tTAT\n";
for (int i = 0; i < n; i++) {
totalWaitingTime += p[i].waitingTime;
totalTurnaroundTime += p[i].turnaroundTime;
cout << p[i].id << "\t"
<< p[i].arrivalTime << "\t"
<< p[i].burstTime << "\t"
<< p[i].completionTime << "\t"
<< p[i].waitingTime << "\t"
<< p[i].turnaroundTime << "\n";
}
cout << "\nAverage Waiting Time: " << (totalWaitingTime / n);
cout << "\nAverage Turnaround Time: " << (totalTurnaroundTime / n) <<
endl;
}
int main() {
int n;
cout << "Enter number of processes: ";
cin >> n;
Process p[n];
cout << "Enter arrival time and burst time for each process:\n";
for (int i = 0; i < n; i++) {
p[i].id = i + 1;
cout << "Process " << i + 1 << ": ";
cin >> p[i].arrivalTime >> p[i].burstTime;
}
findAverageTime(p, n);
return 0;
}
Output:
Question 3: Priority Scheduling
#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;
struct Process {
int id, arrivalTime, burstTime, priority, remainingTime;
int completion, turnaround, waiting, startTime;
bool completed;
};
bool compareArrival(const Process& a, const Process& b) {
return a.arrivalTime < b.arrivalTime;
}
void preemptivePriorityScheduling(vector<Process>& processes, double* avgTAT,
double* avgWT) {
int n = processes.size();
int completed_process = 0, maxPriority, time = 0;
int totalTAT = 0, totalWT = 0;
sort(processes.begin(), processes.end(), compareArrival);
while (completed_process < n) {
int startIndex = -1;
maxPriority = INT_MIN;
for (int i = 0; i < n; i++) {
if (processes[i].arrivalTime <= time &&
processes[i].remainingTime > 0) {
if (processes[i].priority > maxPriority) {
maxPriority = processes[i].priority;
startIndex = i;
} else if (processes[i].priority == maxPriority &&
processes[i].arrivalTime < processes[startIndex].arrivalTime) {
startIndex = i;
}
}
}
if (startIndex == -1) {
time++;
} else {
processes[startIndex].remainingTime--;
time++;
if (processes[startIndex].remainingTime == 0) {
processes[startIndex].completion = time;
processes[startIndex].turnaround =
processes[startIndex].completion - processes[startIndex].arrivalTime;
processes[startIndex].waiting =
processes[startIndex].turnaround - processes[startIndex].burstTime;
totalTAT += processes[startIndex].turnaround;
totalWT += processes[startIndex].waiting;
completed_process++;
}
}
}
*avgTAT = (double)totalTAT / n;
*avgWT = (double)totalWT / n;
}
void nonPreemptivePriorityScheduling(vector<Process>& processes, double*
avgTAT, double* avgWT) {
int n = processes.size();
int completed_process = 0, time = 0, maxPriority;
int totalTAT = 0, totalWT = 0;
sort(processes.begin(), processes.end(), compareArrival);
while (completed_process < n) {
int startIndex = -1;
maxPriority = INT_MIN;
for (int i = 0; i < n; i++) {
if (processes[i].arrivalTime <= time && !processes[i].completed) {
if (processes[i].priority > maxPriority) {
maxPriority = processes[i].priority;
startIndex = i;
} else if (processes[i].priority == maxPriority &&
processes[i].arrivalTime < processes[startIndex].arrivalTime) {
startIndex = i;
}
}
}
if (startIndex == -1) {
time++;
} else {
time += processes[startIndex].burstTime;
processes[startIndex].completion = time;
processes[startIndex].turnaround =
processes[startIndex].completion - processes[startIndex].arrivalTime;
processes[startIndex].waiting = processes[startIndex].turnaround -
processes[startIndex].burstTime;
processes[startIndex].completed = true;
totalTAT += processes[startIndex].turnaround;
totalWT += processes[startIndex].waiting;
completed_process++;
}
}
*avgTAT = (double)totalTAT / n;
*avgWT = (double)totalWT / n;
}
int main() {
int n, choice;
cout << "Enter the number of processes: ";
cin >> n;
vector<Process> processes(n);
cout << "Enter Process ID, Arrival Time, Burst Time, and Priority: \n";
for (int i = 0; i < n; i++) {
cin >> processes[i].id >> processes[i].arrivalTime >>
processes[i].burstTime >> processes[i].priority;
processes[i].remainingTime = processes[i].burstTime;
processes[i].completed = false;
}
cout << "Choose Scheduling Type:\n1. Preemptive Priority Scheduling\n2.
Non-Preemptive Priority Scheduling\nEnter choice: ";
cin >> choice;
double avgTAT, avgWT;
if (choice == 1) {
preemptivePriorityScheduling(processes, &avgTAT, &avgWT);
} else if (choice == 2) {
nonPreemptivePriorityScheduling(processes, &avgTAT, &avgWT);
} else {
cout << "Invalid choice!";
return 0;
}
cout << "\nP \tAT \tBT \tPriority \tCT \tTAT \tWT \n";
for (auto& p : processes) {
cout << p.id << "\t" << p.arrivalTime << "\t" << p.burstTime << "\t"
<< p.priority << "\t\t" << p.completion << "\t" << p.turnaround << "\t" <<
p.waiting << "\n";
}
cout << "\nAverage Turnaround Time: " << avgTAT << "\n";
cout << "Average Waiting Time: " << avgWT << "\n";
return 0;
}
Output :
Question 4: Multi-level queue scheduling
#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
void roundRobin(queue<int> &q, int n, int burstTime[], int waitingTime[], int
turnaroundTime[]) {
int remainingTime[n], startTime[n];
for (int i = 0; i < n; i++) {
remainingTime[i] = burstTime[i];
startTime[i] = -1;
}
int currentTime = 0;
while (!q.empty()) {
int i = q.front();
q.pop();
if (startTime[i] == -1) startTime[i] = currentTime;
int executionTime = min(remainingTime[i], 1);
remainingTime[i] -= executionTime;
currentTime += executionTime;
if (remainingTime[i] > 0)
q.push(i);
else {
turnaroundTime[i] = currentTime;
waitingTime[i] = turnaroundTime[i] - burstTime[i];
}
}
}
void sjf(vector<int> &queue, int burstTime[], int waitingTime[], int
turnaroundTime[]) {
sort(queue.begin(), queue.end(), [&](int a, int b) { return burstTime[a] <
burstTime[b]; });
int currentTime = 0;
for (int i : queue) {
waitingTime[i] = currentTime;
turnaroundTime[i] = waitingTime[i] + burstTime[i];
currentTime += burstTime[i];
}
}
void fcfs(queue<int> &q, int n, int burstTime[], int waitingTime[], int
turnaroundTime[]) {
int currentTime = 0;
while (!q.empty()) {
int i = q.front();
q.pop();
waitingTime[i] = currentTime;
turnaroundTime[i] = waitingTime[i] + burstTime[i];
currentTime += burstTime[i];
}
}
int main() {
int n;
cout << "Enter the number of processes: ";
cin >> n;
int queueType[n], burstTime[n], waitingTime[n] = {0}, turnaroundTime[n] =
{0};
queue<int> highPriority;
vector<int> midPriority;
queue<int> lowPriority;
cout << "Enter Burst Time and Queue Type (1=RR, 2=SJF, 3=FCFS) for each
process:\n";
for (int i = 0; i < n; i++) {
cin >> burstTime[i] >> queueType[i];
if (queueType[i] == 1)
highPriority.push(i);
else if (queueType[i] == 2)
midPriority.push_back(i);
else
lowPriority.push(i);
}
roundRobin(highPriority, n, burstTime, waitingTime, turnaroundTime);
sjf(midPriority, burstTime, waitingTime, turnaroundTime);
fcfs(lowPriority, n, burstTime, waitingTime, turnaroundTime);
float totalWaitingTime = 0, totalTurnaroundTime = 0;
cout << "\nPId\tQueue\tBT\tWT\tTAT\n";
for (int i = 0; i < n; i++) {
totalWaitingTime += waitingTime[i];
totalTurnaroundTime += turnaroundTime[i];
cout << i + 1 << "\t" << queueType[i] << "\t" << burstTime[i] << "\t"
<< waitingTime[i] << "\t" << turnaroundTime[i] << "\n";
}
cout << "\nAverage Waiting Time: " << totalWaitingTime / n;
cout << "\nAverage Turnaround Time: " << totalTurnaroundTime / n;
cout << "\nThroughput: " << (float)n / totalTurnaroundTime << " processes
per unit time\n";
return 0;
}
Output :
