Scheduling Algorithms Implementation

Lab Assignment # 2
Operating Systems

Submitted to: Sir Basharat Mehmood

Submitted by: Fakhir Arslan (FA16-BCS-002)
Muhammad Taha (FA16-BCS-012)
Osama Rana (FA16-BCS-030)
Izza Tipu (FA16-BCS-040)
Dated: 13th December 2018
Class: BCS-5A
CODE:

#include <iostream>
#include <string>

using namespace std;

float avgWaitingTime;
float avgTurnAroundTime;
int INT_MAX = 2147483647;

struct Process{
int pid;
int burstTime;
int arrivalTime;
int priority;
int waitingTime = 0;
int turnAroundTime = 0;
int remainingTime = burstTime;
};

Process* takeProcesses(int totalProcesses){

Process* processes = new Process[totalProcesses];
for(int i = 0 ; i < totalProcesses ; i++){
cout << "Enter process id: ";
cin >> processes[i].pid;
cout << "Enter arrival time: ";
cin >> processes[i].arrivalTime;
cout << "Enter burst time: ";
cin >> processes[i].burstTime;
cout << "Enter priority: ";
cin >> processes[i].priority;
cout << endl;
}
 return processes;
}

void showTable(Process* processes, int totalProcesses){

cout << "Process ID" << "\tArrival Time" << "\tBurst Time" << "\tPriority" << "\tWaiting Time" <<
"\tTurn Around Time" << endl;
for(int i = 0 ; i < totalProcesses ; i++){
cout << processes[i].pid << "\t\t" << processes[i].arrivalTime << "\t\t" << processes[i].burstTime <<
"\t\t" << processes[i].priority << "\t\t" << processes[i].waitingTime << "\t\t" <<
processes[i].turnAroundTime << endl;
}
}

void showTableWithRemainingTime(Process* processes, int totalProcesses){

cout << "Process ID" << "\tArrival Time" << "\tBurst Time" << "\tRemaining Time" << endl;
for(int i = 0 ; i < totalProcesses ; i++){
cout << processes[i].pid << "\t\t" << processes[i].arrivalTime << "\t\t" << processes[i].burstTime <<
"\t\t" << processes[i].remainingTime << endl;
}
}

void showTableWithPriority(Process* processes, int totalProcesses){

cout << "Process ID" << "\tArrival Time" << "\tBurst Time" << "\tPriority" << "\tRemaining Time" <<
endl;
for(int i = 0 ; i < totalProcesses ; i++){
cout << processes[i].pid << "\t\t" << processes[i].arrivalTime << "\t\t" << processes[i].burstTime <<
"\t\t" << processes[i].priority << "\t\t" << processes[i].remainingTime << endl;
}
}

void calculateAvgWaitingTimeAndAvgTurnArounTime(Process* processes, int totalProcesses){

//Waiting Time
processes[0].waitingTime = 0; //As waiting time for the first process would be zero.
processes[0].turnAroundTime = processes[0].burstTime;
 int totalWaitingTime = 0;
int totalTurnAroundTime = processes[0].burstTime;

for(int i = 1 ; i < totalProcesses ; i++){

for(int j = 0 ; j < i ; j++){
processes[i].waitingTime += processes[j].burstTime;
}
totalWaitingTime += processes[i].waitingTime;
processes[i].turnAroundTime = processes[i].waitingTime + processes[i].burstTime;
totalTurnAroundTime += processes[i].turnAroundTime;
}
avgWaitingTime = (float)totalWaitingTime / totalProcesses;
avgTurnAroundTime = (float)totalTurnAroundTime / totalProcesses;
}

void setWaitingTurnAroundAndRemainingTimeToOfAllProcesseToZero(Process* processes, int

totalProcesses){
for(int i = 0 ; i < totalProcesses ; i++){
processes[i].waitingTime = 0;
processes[i].turnAroundTime = 0;
processes[i].remainingTime = 0;
}
}

void firstComeFirstServe(Process* processes, int totalProcesses){

for(int i = 0 ; i < totalProcesses - 1 ; i++){
for(int j = 0 ; j < totalProcesses - 1 ; j++){
if(processes[j].arrivalTime > processes[j + 1].arrivalTime){
Process temp = processes[j];
processes[j] = processes[j + 1];
processes[j + 1] = temp;
}
}
 }
}

void shortestJobFirstNonPreemptive(Process* processes, int totalProcesses){

for(int i = 0 ; i < totalProcesses - 1 ; i++){
for(int j = 0 ; j < totalProcesses - 1 ; j++){
if(processes[j].arrivalTime > processes[j + 1].arrivalTime){
Process temp = processes[j];
processes[j] = processes[j + 1];
processes[j + 1] = temp;
}
}
}

for(int i = 0 ; i < totalProcesses - 1 ; i++){

for(int j = 0 ; j < totalProcesses - 1 ; j++){
if(processes[j].arrivalTime == processes[j + 1].arrivalTime){
if(processes[j].burstTime > processes[j + 1].burstTime){
Process temp = processes[j];
processes[j] = processes[j + 1];
processes[j + 1] = temp;
}
}
}
}
}

//Waiting time and turn around time are calculated inside the funtion.
void shortestJobFirstPreemptive(Process* processes, int totalProcesses){
cout << "Shortest Job First Preemptive Running" << endl;

//Copy burst time to remaining time.

for(int i = 0 ; i < totalProcesses ; i++){
processes[i].remainingTime = processes[i].burstTime;
}

for(int i = 0 ; i < totalProcesses - 1 ; i++){

for(int j = 0 ; j < totalProcesses - 1 ; j++){
if(processes[j].arrivalTime > processes[j + 1].arrivalTime){
Process temp = processes[j];
processes[j] = processes[j + 1];
processes[j + 1] = temp;
}
}
}

int processesCompleted = 0, time = 0;

int shortestIncompleteProcessIndex = 0;
while(processesCompleted != totalProcesses){
for(int i = 0 ; i < totalProcesses - 1 ; i++){
for(int j = 0 ; j < totalProcesses - 1 ; j++){
if((processes[j].arrivalTime <= time) &&
(processes[j + 1].arrivalTime <= time)){
if(processes[j].remainingTime > processes[j + 1].remainingTime){
Process temp = processes[j];
processes[j] = processes[j + 1];
processes[j + 1] = temp;
}
}
}
}

//Waiting time
for(int i = 0 ; i < totalProcesses ; i++){
if(processes[i].arrivalTime <= time && i > shortestIncompleteProcessIndex){
processes[i].waitingTime++;
}
}
 time++;
if(processes[shortestIncompleteProcessIndex].remainingTime > 0){
processes[shortestIncompleteProcessIndex].remainingTime--;
}else{
processesCompleted++;
shortestIncompleteProcessIndex++;
}

cout << "Time = " << time << endl;

showTableWithRemainingTime(processes, totalProcesses);
cout << endl;
}

//Total waiting time

int totalWaitingTime = 0;
for(int i = 0 ; i < totalProcesses ; i++){
totalWaitingTime += processes[i].waitingTime;
}
avgWaitingTime = totalWaitingTime / totalProcesses;

//Turn around time

int totalTurnAroundTime = 0;
for(int i = 0 ; i < totalProcesses ; i++){
processes[i].turnAroundTime = processes[i].burstTime + processes[i].waitingTime;
totalTurnAroundTime += processes[i].turnAroundTime;
}
avgTurnAroundTime = totalTurnAroundTime / totalProcesses;
}

void priorityBasedSchedulingNonPreemptive(Process* processes, int totalProcesses){

for(int i = 0 ; i < totalProcesses - 1 ; i++){
for(int j = 0 ; j < totalProcesses - 1 ; j++){
if(processes[j].arrivalTime > processes[j + 1].arrivalTime){
 Process temp = processes[j];
processes[j] = processes[j + 1];
processes[j + 1] = temp;
}
}
}

for(int i = 0 ; i < totalProcesses - 1 ; i++){

for(int j = 0 ; j < totalProcesses - 1 ; j++){
if(processes[j].arrivalTime == processes[j + 1].arrivalTime){
if(processes[j].priority > processes[j + 1].priority){
Process temp = processes[j];
processes[j] = processes[j + 1];
processes[j + 1] = temp;
}
}
}
}
}

//Waiting and turn around time are calculated inside the function
void priorityBasedSchedulingPreemptive(Process* processes, int totalProcesses){
cout << "Priority Based Scheduling Preemptive Running" << endl;

//Copy burst time to remaining time.

for(int i = 0 ; i < totalProcesses ; i++){
processes[i].remainingTime = processes[i].burstTime;
}

for(int i = 0 ; i < totalProcesses - 1 ; i++){

for(int j = 0 ; j < totalProcesses - 1 ; j++){
if(processes[j].arrivalTime > processes[j + 1].arrivalTime){
Process temp = processes[j];
processes[j] = processes[j + 1];
 processes[j + 1] = temp;
}
}
}

int processesCompleted = 0, time = 0;

int highestPriorityIncompleteProcessIndex = 0;
while(processesCompleted != totalProcesses){
for(int i = 0 ; i < totalProcesses - 1 ; i++){
for(int j = 0 ; j < totalProcesses - 1 ; j++){
if((processes[j].arrivalTime <= time) &&
(processes[j + 1].arrivalTime <= time)){
if(processes[j].priority > processes[j + 1].priority){
Process temp = processes[j];
processes[j] = processes[j + 1];
processes[j + 1] = temp;
}
}
}
}

//Waiting time
for(int i = 0 ; i < totalProcesses ; i++){
if(processes[i].arrivalTime <= time && i > highestPriorityIncompleteProcessIndex){
processes[i].waitingTime++;
}
}

//Increment Time
time++;
if(processes[highestPriorityIncompleteProcessIndex].remainingTime > 0){
processes[highestPriorityIncompleteProcessIndex].remainingTime--;
}else{
processesCompleted++;
 highestPriorityIncompleteProcessIndex++;
}

cout << "Time = " << time << endl;

showTableWithPriority(processes, totalProcesses);
cout << endl;
}

//Total waiting time

int totalWaitingTime = 0;
for(int i = 0 ; i < totalProcesses ; i++){
totalWaitingTime += processes[i].waitingTime;
}
avgWaitingTime = totalWaitingTime / totalProcesses;

//Turn around time

int totalTurnAroundTime = 0;
for(int i = 0 ; i < totalProcesses ; i++){
processes[i].turnAroundTime = processes[i].burstTime + processes[i].waitingTime;
totalTurnAroundTime += processes[i].turnAroundTime;
}
avgTurnAroundTime = totalTurnAroundTime / totalProcesses;
}

int main() {
cout << "Enter number of processes: ";
int totalProcesses;
cin >> totalProcesses;
Process* processes = takeProcesses(totalProcesses);

firstComeFirstServe(processes, totalProcesses);
cout << "********** First Come First Serve **********" << endl;
calculateAvgWaitingTimeAndAvgTurnArounTime(processes, totalProcesses);
showTable(processes, totalProcesses);
 cout << "Average Waiting Time: " << avgWaitingTime << endl;
cout << "Average Turn Around Time: " << avgTurnAroundTime << endl << endl;

setWaitingTurnAroundAndRemainingTimeToOfAllProcesseToZero(processes, totalProcesses);

shortestJobFirstNonPreemptive(processes, totalProcesses);
cout << "********** Shortest Job First Non Preemptive **********" << endl;
calculateAvgWaitingTimeAndAvgTurnArounTime(processes, totalProcesses);
showTable(processes, totalProcesses);
cout << "Average Waiting Time: " << avgWaitingTime << endl;
cout << "Average Turn Around Time: " << avgTurnAroundTime << endl << endl;

setWaitingTurnAroundAndRemainingTimeToOfAllProcesseToZero(processes, totalProcesses);

shortestJobFirstPreemptive(processes, totalProcesses); //waiting time and turn around time are

calculated inside the function
cout << "********** Shortest Job First Preemptive **********" << endl;
showTable(processes, totalProcesses);
cout << "Average Waiting Time: " << avgWaitingTime << endl;
cout << "Average Turn Around Time: " << avgTurnAroundTime << endl << endl;

setWaitingTurnAroundAndRemainingTimeToOfAllProcesseToZero(processes, totalProcesses);
//
priorityBasedSchedulingNonPreemptive(processes, totalProcesses);
cout << "********** Priority Based Scheduling Non Preemptive **********" << endl;
calculateAvgWaitingTimeAndAvgTurnArounTime(processes, totalProcesses);
showTable(processes, totalProcesses);
cout << "Average Waiting Time: " << avgWaitingTime << endl;
cout << "Average Turn Around Time: " << avgTurnAroundTime << endl << endl;

setWaitingTurnAroundAndRemainingTimeToOfAllProcesseToZero(processes, totalProcesses);

priorityBasedSchedulingPreemptive(processes, totalProcesses); //waiting time and turn around time

are calculated inside the function
 cout << "********** Priority Based Scheduling Preemptive **********" << endl;
showTable(processes, totalProcesses);
cout << "Average Waiting Time: " << avgWaitingTime << endl;
cout << "Average Turn Around Time: " << avgTurnAroundTime << endl << endl;

setWaitingTurnAroundAndRemainingTimeToOfAllProcesseToZero(processes, totalProcesses);

return 0;
}