SchedulingAlgorithmsSimulation/Simulation.cpp at main · larezelliot/SchedulingAlgorithmsSimulation · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
#pragma once
#include "Simulation.h"

void Simulation::generateProcess()
{
	int burstNumber = rand() % (burstNumberMax - burstNumberMin + 1) + burstNumberMin;

	std::queue<int> burstTimes;
	std::queue<int> ioTimes;

	int burstTime = rand() % (burstTimeMax - burstTimeMin + 1) + burstTimeMin;
	int ioTime = rand() % (ioTimeMax - ioTimeMin + 1) + ioTimeMin;

	for (int i = 0; i < burstNumber; i++) {

		burstTimes.push(burstTime);

		ioTimes.push(ioTime);
	}

	Process* process = new Process(burstTimes, ioTimes);
	processes.push_back(process);
	cpu->addProcess(process);
}


Simulation::Simulation(int seed, int burstNumberMin, int burstNumberMax, int burstTimeMin, int burstTimeMax, int ioTimeMin, int ioTimeMax, int arrivalInterval, int maximumProcesses, std::string scheduler) :
	seed(seed),
	burstNumberMin(burstNumberMin),
	burstNumberMax(burstNumberMax),
	burstTimeMin(burstTimeMin),
	burstTimeMax(burstTimeMax),
	ioTimeMin(ioTimeMin),
	ioTimeMax(ioTimeMax),
	arrivalInterval(arrivalInterval),
	maximumProcesses(maximumProcesses),
	scheduler(scheduler)
{
	srand(seed);

	if (scheduler == "FIFO")
		cpu = new CPU(new FIFOScheduler());
	else
		cpu = new CPU(new ExpAvgScheduler());
}


Simulation::~Simulation()
{
	delete cpu;

	//HACK: Be careful in this part using foreach while dereferencing
	for (Process* process : processes)
		delete process;
}

void Simulation::run()
{
	int time = 0;
	generateProcess();
	int lastArrival = 0;


	std::cout << scheduler << "Simulation Started: (seed #" << seed << ")\n";
	std::cout << "0%______________________________________________________________________________________________100%\n";

	int jobsCompleted = 0;
	double nextMile = maximumProcesses/100;
	int i = 0;

	while(jobsCompleted < maximumProcesses) {
		if (lastArrival == arrivalInterval && processes.size()<maximumProcesses) {
			generateProcess();
			lastArrival = 0;
		}

		cpu->update();

		jobsCompleted = 0;
		for (Process* process : processes) {
			process->update();
			if (process->getState() == "Terminated")
				jobsCompleted++;
			//process->printProcess();
		}

		if (jobsCompleted >= nextMile) {
			std::cout << "*";
			nextMile += maximumProcesses / 100.00;
		}

		lastArrival++;
		time++;
	}
	std::cout << "\n";

	double avgRunningTime = 0;
	double avgIOTime = 0;
	double avgWaitTime = 0;
	jobsCompleted = 0;
	for (Process* process : processes)
		if (process->isCompleted()) {
			avgRunningTime += process->getTimeRunning();
			avgIOTime += process->getTimeIO();
			avgWaitTime += process->getTimeWaiting();
			jobsCompleted++;
		}
	avgRunningTime /= jobsCompleted;
	avgIOTime /= jobsCompleted;
	avgWaitTime /= jobsCompleted;

	std::cout << scheduler << " Simulation Completed: (seed #" <<  seed << ")\n";
	std::cout << "-----------------------------------------\n";
	std::cout << "\tTime Running: " << time << "\n";
	std::cout << "\tArrived Processes: " << processes.size() << "\n";
	std::cout << "\tNumber of Burst per Process: (" << burstNumberMin << ", " << burstNumberMax << ")\n";
	std::cout << "\tTime per Burst: (" << burstTimeMin << ", " << burstTimeMax << ")\n";
	std::cout << "\tTime per I/O wait: (" << ioTimeMin << ", " << ioTimeMax << ")\n";
	std::cout << "\tArrival Interval: " << arrivalInterval << "\n\n";

	std::cout << "\tJobs Completed: "<< jobsCompleted << "(" << 100.00*jobsCompleted/processes.size() << "%)\n";
	std::cout << "\tAverage Running Time per job: " << avgRunningTime << "\n";
	std::cout << "\tAverage I/O Time per job: " << avgIOTime << "\n";
	std::cout << "\tAverage Wait Time per job: "<< avgWaitTime <<"\n\n";
}