Multi-level queue scheduling (Using FCFS and Round Robin scheduling on individual queues)

MultiLevelQueue.cpp

#include <iostream>
#include <queue>
#include <vector>
#include <unordered_map>

typedef uint32_t uint;

struct process {
	uint32_t pid;
	uint32_t atime;
	uint32_t btime;
	uint32_t wtime = 0;
	uint32_t tatime = 0;
	uint32_t ctime = 0;
	uint32_t qp;
	process(uint32_t pid, uint32_t atime, uint32_t btime, uint32_t qp) : pid(pid), atime(atime), btime(btime), qp(qp) {};
	process() {};
};

int main() {
	process p1(0, 0, 4, 1);
	process p2(1, 0, 3, 1);
	process p3(2, 0, 8, 2);
	process p4(3, 10, 5, 1);

	std::vector<process> processList = { p1,p2,p3,p4 };
	std::unordered_map<uint32_t, process*> pidAccess;
	
	for (uint i = 0; i < processList.size(); i++) {
		pidAccess[i] = &processList[i];
	}

	std::unordered_map<uint32_t, std::vector<process>> tpMap;
	
	tpMap[0] = { p1,p2,p3 };
	tpMap[10] = { p4 };

	uint t = 0;

	std::vector<process> processQ1;	// FCFS - 1
	std::queue<process> rr_que;		// RR - 2

	int quantum = 2;
	bool loop = true;
  
	int ptr1 = 0;
	while (loop) {
		if (tpMap.find(t) != tpMap.end()) {
			for (uint i = 0; i < tpMap[t].size(); i++) {
				if (tpMap[t][i].qp == 1) {
					processQ1.push_back(tpMap[t][i]);
				}
				else {
					rr_que.push(tpMap[t][i]);
				}
			}
		}
		if (ptr1 < processQ1.size()) {
				if (processQ1[ptr1].btime != 0) {
					processQ1[ptr1].btime--;
				}
			if (processQ1[ptr1].btime == 0) { processQ1[ptr1].ctime = t + 1; ptr1++; }
		}
		else {
			if (!rr_que.empty()) {
					if (quantum != 0) {
						rr_que.front().btime--;
						quantum--;

						if (rr_que.front().btime == 0) {
							rr_que.front().ctime = t + 1;
							pidAccess[rr_que.front().pid]->ctime = t + 1;
							rr_que.pop();
						}

						if (quantum == 0 && !rr_que.empty()) {
							process& p = rr_que.front();
							rr_que.pop();
							rr_que.push(p);
							quantum = 2;
						}
					}
				}
			else {
				loop = false;
			}
		}
		t++;
	}

	std::cout << "Process in queue 1 (Works on FCFS scheduling): \n";
	for (uint i = 0; i < processQ1.size(); i++) {
		std::cout << "Process-" << processQ1[i].pid << "\n";
		std::cout << "Completion time (On global timeline): " << processQ1[i].ctime<<"\n";
		std::cout << "Turnaround around time: " << processQ1[i].ctime - processQ1[i].atime<<"\n";
		std::cout << "Waiting time: " << (processQ1[i].ctime - processQ1[i].atime) - pidAccess[processQ1[i].pid]->btime << "\n\n";
	}

	std::cout << "Process in queue 2 (Works on Round robin scheduling): \n";
	for (uint i = 0; i < processList.size(); i++) {
		if (processList[i].pid == 2) {
			std::cout << "Process-" << i << "\n";
			std::cout << "Completion time (On global timeline): " << pidAccess[processList[i].pid]->ctime << "\n";
			std::cout << "Turnaround around time: " << pidAccess[processList[i].pid]->ctime - pidAccess[processList[i].pid]->atime << "\n";
			std::cout << "Waiting time: " << (pidAccess[processList[i].pid]->ctime - pidAccess[processList[i].pid]->atime) - pidAccess[processList[i].pid]->btime << "\n\n";
		}
	}

	std::cin.get();
}