Here I have implemented code for Round Robin CPU Scheduling Algorithm. scheduling.h header file is also used in Shortest Job First Scheduling Algorithm and Priority Scheduling Algorithm, so it contains common data members and member functions.
First I have calculated end time in calcEndTime()
then using formula turnAroundTime = endTime - arrivalTime
calculated Turnaround time and using waitingTime = turnAroundTime - burstTime
calculated Waiting time.
Please help me to improve and optimize this code using more C++11 and C++14 features.
scheduling.h
#ifndef SCHEDULING_H_
#define SCHEDULING_H_
#include <vector>
class Scheduling
{
uint currActiveProcessID;
uint timeCounter = 0;
double avgWaitingTime;
double avgTurnAroundTime;
std::vector<unsigned> arrivalTime;
//When process start to execute
std::vector<unsigned> burstTime;
//process wait to execute after they have arrived
std::vector<unsigned> waitingTime;
//total time taken by processes
std::vector<unsigned> turnAroundTime;
//time when a process end
std::vector<unsigned> endTime;
public:
Scheduling(unsigned num = 0);
Scheduling(const Scheduling&) = delete;
Scheduling &operator=(const Scheduling&) = delete;
Scheduling(Scheduling&&) = delete;
Scheduling &operator=(Scheduling&&) = delete;
~Scheduling() = default;
void calcWaitingTime();
void calcTurnAroundTime();
void calcEndTime();
void printInfo();
private:
void sortAccordingArrivalTime();
};
#endif
roundrobin.cpp
#include <iostream>
#include <vector>
#include <algorithm> // std::find
#include <iterator> // std::begin, std::end
#include <limits> //std::numeric_limits
#include "scheduling.h"
unsigned timeQuantum = 0;
Scheduling::Scheduling(unsigned num)
{
unsigned arrivalVal, burstVal;
currActiveProcessID = 0;
timeCounter = 0;
std::cout << "\nEnter time quantum : ";
std::cin >> timeQuantum;
arrivalTime.reserve(num);
burstTime.reserve(num);
endTime.reserve(num);
std::cout << "\nEnter arrival time and burst time eg(5 18)\n";
for (unsigned i = 0; i < num; i++)
{
std::cout << "\nProcess" << i+1 << ": ";
std::cin >> arrivalVal >> burstVal;
arrivalTime.push_back(arrivalVal);
burstTime.push_back(burstVal);
}
}
void Scheduling::sortAccordingArrivalTime()
{
for (std::size_t i = 0; i < arrivalTime.size(); i++)
{
for (std::size_t j = i+1; j < arrivalTime.size(); j++)
{
if (arrivalTime[i] > arrivalTime[j])
{
std::swap(arrivalTime[i], arrivalTime[j]);
std::swap(burstTime[i], burstTime[j]);
}
}
}
}
void Scheduling::calcEndTime()
{
//If arrival time is not sorted
//sort burst time according to arrival time
sortAccordingArrivalTime();
//copy values of burst time in new vector
std::vector<unsigned> burstTimeCopy;
std::copy(burstTime.begin(), burstTime.end(),
std::back_inserter(burstTimeCopy));
while (!(std::all_of(burstTimeCopy.begin(), burstTimeCopy.end(),
[] (unsigned e) { return e == 0; })))
{
currActiveProcessID = 0;
auto it = burstTimeCopy.begin();
while (it != burstTimeCopy.end())
{
if (burstTimeCopy[currActiveProcessID] > timeQuantum)
{
burstTimeCopy[currActiveProcessID] -= timeQuantum;
timeCounter += timeQuantum;
}
else if (burstTimeCopy[currActiveProcessID] > 0)
{
timeCounter += burstTimeCopy[currActiveProcessID];
burstTimeCopy[currActiveProcessID] = 0;
endTime[currActiveProcessID] = timeCounter;
}
currActiveProcessID++;
it++;
}
}
}
void Scheduling::calcTurnAroundTime()
{
double sum = 0.00;
for (std::size_t i = 0; i < arrivalTime.size(); i++)
{
unsigned val = endTime[i] - arrivalTime[i];
turnAroundTime.push_back(val);
sum += (double)val;
}
avgTurnAroundTime = sum / turnAroundTime.size();
}
void Scheduling::calcWaitingTime()
{
double sum = 0.00;
for (std::size_t i = 0; i < burstTime.size(); i++)
{
unsigned val = turnAroundTime[i] - burstTime[i];
waitingTime.push_back(val);
sum += (double)val;
}
avgWaitingTime = sum / waitingTime.size();
}
void Scheduling::printInfo()
{
std::cout << "ProcessID\tArrival Time\tBurst Time\tEnd Time\tWaiting Time";
std::cout << "\tTurnaround Time\n";
for (std::size_t i = 0; i < arrivalTime.size(); i++)
{
std::cout << i+1 << "\t\t" << arrivalTime[i] << "\t\t" << burstTime[i];
std::cout << "\t\t"<<endTime[i] << "\t\t" << waitingTime[i] <<"\t\t";
std::cout << turnAroundTime[i] <<'\n';
}
std::cout << "Average Waiting Time : " << avgWaitingTime << '\n';
std::cout << "Average Turn Around Time : " << avgTurnAroundTime << '\n';
}
int main()
{
int num;
std::cout << "Enter number of process: ";
std::cin >> num;
Scheduling roundRobin(num);
roundRobin.calcEndTime();
roundRobin.calcTurnAroundTime();
roundRobin.calcWaitingTime();
roundRobin.printInfo();
}
uint
. Was this intended to beunsigned
, or is the definition missing entirely (e.g. by missing an#include
)? \$\endgroup\$using uint = unsigned int
then I thought it is better to useunsigned
. I forgot to change that. \$\endgroup\$