Simulator.cpp

#include "Simulator.h"

#include <algorithm>
#include <utility>

Simulator::Simulator(IScheduler* scheduler, const int timeQuantum) : timeQuantum(timeQuantum), scheduler(scheduler) {}

std::vector<ProcessResult>& Simulator::GetResults() {
	if (wasRun==false) {
		Run();
	}
	wasRun=true;
	return executionLog;
}

void Simulator::AssignData(std::vector<ProcessBlueprint> data) {
	processBlueprints = std::move(data);
	wasRun=false;

}

void Simulator::AssignScheduler(IScheduler* newScheduler) {
	scheduler = newScheduler;
	HardReset();
}

std::vector<Process*> Simulator::checkNewArrivals() {
	std::vector<Process*> result;

	if (processes.empty()) {
		return result;
	}

	while (!processes.empty() && processes.top().arrivalTime == currentTime) {
		result.push_back(new Process(processes.top()));
		processes.pop();
	}

	return result;
}

void Simulator::SoftReset() {
	executionLog.clear();
	currentTime = 0;

	while (!processes.empty()) {
		processes.pop();
	}
	for (const auto& blueprint : processBlueprints) {
		processes.emplace(blueprint);
	}
	wasRun=false;
}

void Simulator::HardReset() {
	processBlueprints.clear();
	executionLog.clear();
	currentTime = 0;
	wasRun=false;
}

void Simulator::Run() {
	SoftReset();

	do {
		const auto& lastProcess = scheduler->getCurrentProcess();
		std::vector<Process*> newArrivals = checkNewArrivals();

		if (!newArrivals.empty()) {
			scheduler->UpdateByArrivals(newArrivals);
		}

		if (currentTime % timeQuantum == 0) {
			scheduler->DoAging();
		}

		if (currentBatchTime >= timeQuantum || scheduler->ShouldSelect())
		{
			scheduler->SelectProcess();
			currentBatchTime = 0;
		}

		Process* process = scheduler->getCurrentProcess();

		if (lastProcess != process) {
			if (lastProcess != nullptr && lastProcess->lastTimeSetActive != -1) {
				lastProcess->activeTimes.emplace_back(lastProcess->lastTimeSetActive, currentTime);
				lastProcess->lastTimeSetActive = -1;
			}
			if (process != nullptr) {
				process->lastTimeSetActive = currentTime;
			}
		}

		if (process == nullptr || process->currentState == Finished) {
			//TODO: WHY???
			//ProcessResult temp;
			//executionLog.push_back(temp);
		} else {
			process->Run(1, currentTime);
			currentBatchTime++;

			if (process->currentState == Finished) {
				if (auto result = scheduler->NotifyFinished(process->id, currentTime)) {
					executionLog.push_back(std::move(*result));
				}
				delete process;
			}
		}

		currentTime++;
	} while (!processes.empty() || !scheduler->isEmpty());
	wasRun=true;
}

int Simulator::GetTimeQuantum() {
	return timeQuantum;
}

void Simulator::setTimeQuantum(int time) {
	timeQuantum = time;
}