1 : |
agomez |
1 |
#include "processmanager.h" |
2 : |
|
|
|
3 : |
|
|
RunTime::RunTime() {
|
4 : |
|
|
execTime = -1.0;
|
5 : |
|
|
startExec = -1;
|
6 : |
|
|
}
|
7 : |
|
|
|
8 : |
|
|
RunTime::~RunTime() {
|
9 : |
|
|
}
|
10 : |
|
|
|
11 : |
|
|
void RunTime::startRun() {
|
12 : |
|
|
startExec = time(NULL);
|
13 : |
|
|
|
14 : |
|
|
}
|
15 : |
|
|
|
16 : |
|
|
void RunTime::stopRun(double a) {
|
17 : |
|
|
time_t stopExec;
|
18 : |
|
|
double newTime;
|
19 : |
|
|
stopExec = time(NULL);
|
20 : |
|
|
newTime = difftime(stopExec, startExec);
|
21 : |
|
|
|
22 : |
|
|
//minimum run time is set to 1
|
23 : |
|
|
if ((fabs(newTime) < verysmall)) {
|
24 : |
|
|
newTime = execTime;
|
25 : |
|
|
if (newTime == -1.0)
|
26 : |
|
|
execTime = 1.0;
|
27 : |
|
|
}
|
28 : |
|
|
|
29 : |
|
|
if (execTime == -1.0)
|
30 : |
|
|
execTime = newTime;
|
31 : |
|
|
else
|
32 : |
|
|
execTime = (execTime * a) + (newTime * (1 - a));
|
33 : |
|
|
startExec = -1;
|
34 : |
|
|
}
|
35 : |
|
|
|
36 : |
|
|
double RunTime::getRunTime() {
|
37 : |
|
|
return execTime;
|
38 : |
|
|
}
|
39 : |
|
|
|
40 : |
|
|
void RunTime::setRunTime(double t) {
|
41 : |
|
|
execTime = t;
|
42 : |
|
|
}
|
43 : |
|
|
|
44 : |
|
|
time_t RunTime::getStartTime() {
|
45 : |
|
|
return startExec;
|
46 : |
|
|
}
|
47 : |
|
|
|
48 : |
|
|
int RunTime::isRunning() {
|
49 : |
|
|
return !(startExec == -1);
|
50 : |
|
|
}
|
51 : |
|
|
|
52 : |
|
|
ProcessManager::ProcessManager() {
|
53 : |
|
|
maxNumHosts = 500;
|
54 : |
|
|
// Return value if no processes available.
|
55 : |
|
|
errorNoProcesses = -1;
|
56 : |
|
|
// Return value if should wait for processes.
|
57 : |
|
|
errorWaitForProcesses = -2;
|
58 : |
|
|
freeProcesses = new Queue();
|
59 : |
|
|
totalNumProc = 0;
|
60 : |
|
|
procStat = NULL;
|
61 : |
|
|
}
|
62 : |
|
|
|
63 : |
|
|
ProcessManager::~ProcessManager() {
|
64 : |
|
|
delete freeProcesses;
|
65 : |
|
|
freeProcesses = NULL;
|
66 : |
|
|
if (procStat != NULL) {
|
67 : |
|
|
delete[] procStat;
|
68 : |
|
|
procStat = NULL;
|
69 : |
|
|
}
|
70 : |
|
|
}
|
71 : |
|
|
|
72 : |
|
|
void ProcessManager::initializePM(int numProc) {
|
73 : |
|
|
int i;
|
74 : |
|
|
if (numProc <= 0) {
|
75 : |
|
|
cerr << "Error in processmanager - number of processes must be positive\n";
|
76 : |
|
|
exit(EXIT_FAILURE);
|
77 : |
|
|
}
|
78 : |
|
|
totalNumProc = numProc;
|
79 : |
|
|
procStat = new int[totalNumProc];
|
80 : |
|
|
for (i = 0; i < totalNumProc; i++) {
|
81 : |
|
|
procStat[i] = -1;
|
82 : |
|
|
addProc(i);
|
83 : |
|
|
setStatus(i, 1);
|
84 : |
|
|
}
|
85 : |
|
|
}
|
86 : |
|
|
|
87 : |
|
|
void ProcessManager::addProc(int id) {
|
88 : |
|
|
if (id < 0 || id >= totalNumProc) {
|
89 : |
|
|
cerr << "Error in processmanager - invalid process id " << id << endl;
|
90 : |
|
|
exit(EXIT_FAILURE);
|
91 : |
|
|
}
|
92 : |
|
|
if (!(freeProcesses->contains(id))) {
|
93 : |
|
|
freeProcesses->put(id);
|
94 : |
|
|
}
|
95 : |
|
|
else
|
96 : |
|
|
cerr << "Warning in processmanager - process with id " << id << " already exists\n";
|
97 : |
|
|
}
|
98 : |
|
|
|
99 : |
|
|
//jongud Added method to add more processes than to begin with
|
100 : |
|
|
void ProcessManager::addMoreProc(int id) {
|
101 : |
|
|
if (id < 0 || id >= (totalNumProc + 1)) {
|
102 : |
|
|
cerr << "Error in processmanager - invalid process id " << id << endl;
|
103 : |
|
|
exit(EXIT_FAILURE);
|
104 : |
|
|
}
|
105 : |
|
|
if (!(freeProcesses->contains(id))) {
|
106 : |
|
|
freeProcesses->put(id);
|
107 : |
|
|
totalNumProc++;
|
108 : |
|
|
} else
|
109 : |
|
|
cerr << "Warning in processmanager - process with id " << id << " already freed\n";
|
110 : |
|
|
}
|
111 : |
|
|
|
112 : |
|
|
|
113 : |
|
|
int ProcessManager::allReceived() {
|
114 : |
|
|
int numGoodProc = getNumGoodProc();
|
115 : |
|
|
return (freeProcesses->getNumItems() >= numGoodProc);
|
116 : |
|
|
}
|
117 : |
|
|
|
118 : |
|
|
int ProcessManager::getNumFreeProc() {
|
119 : |
|
|
removeBadProc();
|
120 : |
|
|
return (freeProcesses->getNumItems());
|
121 : |
|
|
}
|
122 : |
|
|
|
123 : |
|
|
void ProcessManager::removeBadProc() {
|
124 : |
|
|
int id;
|
125 : |
|
|
int counter = 0;
|
126 : |
|
|
int numFreeProc = freeProcesses->getNumItems();
|
127 : |
|
|
while (counter < numFreeProc) {
|
128 : |
|
|
id = freeProcesses->get();
|
129 : |
|
|
assert((id >= 0) && (id < totalNumProc));
|
130 : |
|
|
if (procStat[id] == 1)
|
131 : |
|
|
freeProcesses->put(id);
|
132 : |
|
|
counter++;
|
133 : |
|
|
}
|
134 : |
|
|
}
|
135 : |
|
|
|
136 : |
|
|
int ProcessManager::isFreeProc() {
|
137 : |
|
|
removeBadProc();
|
138 : |
|
|
return (!(freeProcesses->isEmpty()));
|
139 : |
|
|
}
|
140 : |
|
|
|
141 : |
|
|
int ProcessManager::getNumGoodProc() {
|
142 : |
|
|
int i;
|
143 : |
|
|
int numGoodProc = 0;
|
144 : |
|
|
for (i = 0; i < totalNumProc; i++) {
|
145 : |
|
|
if (procStat[i] == 1)
|
146 : |
|
|
numGoodProc++;
|
147 : |
|
|
}
|
148 : |
|
|
return numGoodProc;
|
149 : |
|
|
}
|
150 : |
|
|
|
151 : |
|
|
void ProcessManager::setFreeProc(int id) {
|
152 : |
|
|
if (id < 0 || id >= totalNumProc) {
|
153 : |
|
|
cerr << "Error in processmanager - invalid process id " << id << endl;
|
154 : |
|
|
exit(EXIT_FAILURE);
|
155 : |
|
|
}
|
156 : |
|
|
if (!(freeProcesses->contains(id)))
|
157 : |
|
|
freeProcesses->put(id);
|
158 : |
|
|
else
|
159 : |
|
|
cerr << "Warning in processmanager - process with id " << id << " already freed\n";
|
160 : |
|
|
}
|
161 : |
|
|
|
162 : |
|
|
int ProcessManager::getTidToSend(NetCommunication* n) {
|
163 : |
|
|
int tid;
|
164 : |
|
|
n->getHealthOfProcesses(procStat);
|
165 : |
|
|
removeBadProc();
|
166 : |
|
|
if (freeProcesses->isEmpty())
|
167 : |
|
|
return errorNoProcesses;
|
168 : |
|
|
else {
|
169 : |
|
|
tid = freeProcesses->get();
|
170 : |
|
|
return tid;
|
171 : |
|
|
}
|
172 : |
|
|
}
|
173 : |
|
|
/*
|
174 : |
|
|
Hvergi kallað á þetta...
|
175 : |
|
|
|
176 : |
|
|
int ProcessManager::checkForNewProcess(NetCommunication* n) {
|
177 : |
|
|
int tid;
|
178 : |
|
|
//Búinn að eyða út getHealthOfProcessesAndHostAdded, sem var útfært í netcommunication.cc
|
179 : |
|
|
tid = n->getHealthOfProcessesAndHostAdded(procStat);
|
180 : |
|
|
removeBadProc();
|
181 : |
|
|
if (tid > -1)
|
182 : |
|
|
addMoreProc(tid);
|
183 : |
|
|
return tid;
|
184 : |
|
|
}
|
185 : |
|
|
|
186 : |
|
|
*/
|
187 : |
|
|
|
188 : |
|
|
int ProcessManager::getNextTidToSend(int numLeftToSend, NetCommunication* n) {
|
189 : |
|
|
int tid;
|
190 : |
|
|
//tid = n->getHealthOfProcessesAndHostAdded(procStat);
|
191 : |
|
|
//removeBadProc();
|
192 : |
|
|
//if (tid > -1)
|
193 : |
|
|
// addMoreProc(tid);
|
194 : |
|
|
//if (freeProcesses->isEmpty())
|
195 : |
|
|
// return errorNoProcesses;
|
196 : |
|
|
//else {
|
197 : |
|
|
cout << "Hello\n";
|
198 : |
|
|
tid = freeProcesses->get();
|
199 : |
|
|
return tid;
|
200 : |
|
|
//}
|
201 : |
|
|
}
|
202 : |
|
|
|
203 : |
|
|
void ProcessManager::sent(int processID) {
|
204 : |
|
|
}
|
205 : |
|
|
|
206 : |
|
|
int* ProcessManager::getStatus() {
|
207 : |
|
|
return procStat;
|
208 : |
|
|
}
|
209 : |
|
|
|
210 : |
|
|
int ProcessManager::getStatus(int id) {
|
211 : |
|
|
if ((id < 0) || (id >= totalNumProc)) {
|
212 : |
|
|
cerr << "Error in processmanager - invalid process id " << id << endl;
|
213 : |
|
|
exit(EXIT_FAILURE);
|
214 : |
|
|
}
|
215 : |
|
|
return procStat[id];
|
216 : |
|
|
}
|
217 : |
|
|
|
218 : |
|
|
void ProcessManager::setStatus(int id, int stat) {
|
219 : |
|
|
if ((id < 0) || (id >= totalNumProc)) {
|
220 : |
|
|
cerr << "Error in processmanager - invalid process id " << id << endl;
|
221 : |
|
|
exit(EXIT_FAILURE);
|
222 : |
|
|
}
|
223 : |
|
|
if ((stat != 1) && (stat != -1)) {
|
224 : |
|
|
cerr << "Error in processmanager - invalid status " << stat << endl;
|
225 : |
|
|
exit(EXIT_FAILURE);
|
226 : |
|
|
}
|
227 : |
|
|
procStat[id] = stat;
|
228 : |
|
|
}
|
229 : |
|
|
|
230 : |
|
|
void ProcessManager::processDown(int id) {
|
231 : |
|
|
setStatus(id, -1);
|
232 : |
|
|
}
|
233 : |
|
|
|
234 : |
|
|
void ProcessManager::noProcessesRunning() {
|
235 : |
|
|
int i;
|
236 : |
|
|
for (i = 0; i < totalNumProc; i++)
|
237 : |
|
|
procStat[i] = -1;
|
238 : |
|
|
while (!freeProcesses->isEmpty())
|
239 : |
|
|
freeProcesses->get();
|
240 : |
|
|
}
|
241 : |
|
|
|
242 : |
|
|
int ProcessManager::noAvailableProcesses() {
|
243 : |
|
|
return errorNoProcesses;
|
244 : |
|
|
}
|
245 : |
|
|
|
246 : |
|
|
int ProcessManager::waitForBetterProcesses() {
|
247 : |
|
|
return errorWaitForProcesses;
|
248 : |
|
|
}
|
249 : |
|
|
|
250 : |
|
|
|
251 : |
|
|
WorkLoadScheduler::WorkLoadScheduler(CommandLineInfo* info) {
|
252 : |
|
|
alpha = info->getRunMultiple();
|
253 : |
|
|
hostMultiple = info->getHostMultiple();
|
254 : |
|
|
besttimeMultiple = info->getBestMultiple();
|
255 : |
|
|
runInfo = NULL;
|
256 : |
|
|
bestTime = 360000.0;
|
257 : |
|
|
}
|
258 : |
|
|
|
259 : |
|
|
WorkLoadScheduler::~WorkLoadScheduler() {
|
260 : |
|
|
int i;
|
261 : |
|
|
if (runInfo != NULL) {
|
262 : |
|
|
for (i = 0; i < totalNumProc; i++)
|
263 : |
|
|
delete runInfo[i];
|
264 : |
|
|
delete[] runInfo;
|
265 : |
|
|
}
|
266 : |
|
|
}
|
267 : |
|
|
|
268 : |
|
|
void WorkLoadScheduler::initializePM(int totalNumProc) {
|
269 : |
|
|
runInfo = new RunTime*[totalNumProc];
|
270 : |
|
|
ProcessManager::initializePM(totalNumProc);
|
271 : |
|
|
}
|
272 : |
|
|
|
273 : |
|
|
void WorkLoadScheduler::addProc(int id) {
|
274 : |
|
|
ProcessManager::addProc(id);
|
275 : |
|
|
runInfo[id] = new RunTime();
|
276 : |
|
|
}
|
277 : |
|
|
|
278 : |
|
|
void WorkLoadScheduler::addMoreProc(int id) {
|
279 : |
|
|
ProcessManager::addMoreProc(id);
|
280 : |
|
|
runInfo[id] = new RunTime();
|
281 : |
|
|
}
|
282 : |
|
|
|
283 : |
|
|
void WorkLoadScheduler::setFreeProc(int tid) {
|
284 : |
|
|
runInfo[tid]->stopRun(alpha);
|
285 : |
|
|
if (bestTime > runInfo[tid]->getRunTime())
|
286 : |
|
|
bestTime = runInfo[tid]->getRunTime();
|
287 : |
|
|
ProcessManager::setFreeProc(tid);
|
288 : |
|
|
}
|
289 : |
|
|
|
290 : |
|
|
int WorkLoadScheduler::getNextTidToSend(int numLeftToSend, NetCommunication* n) {
|
291 : |
|
|
int id, q;
|
292 : |
|
|
int nextTid = -1;
|
293 : |
|
|
n->getHealthOfProcesses(procStat);
|
294 : |
|
|
ProcessManager::removeBadProc();
|
295 : |
|
|
if (freeProcesses->isEmpty()) {
|
296 : |
|
|
return errorNoProcesses;
|
297 : |
|
|
} else if (numLeftToSend >= hostMultiple * totalNumProc) {
|
298 : |
|
|
nextTid = freeProcesses->get();
|
299 : |
|
|
return nextTid;
|
300 : |
|
|
} else {
|
301 : |
|
|
id = quickHostsAvailable();
|
302 : |
|
|
if (id >= 0)
|
303 : |
|
|
return id;
|
304 : |
|
|
|
305 : |
|
|
q = quickBusyProcesses();
|
306 : |
|
|
if (q == 1)
|
307 : |
|
|
return errorWaitForProcesses;
|
308 : |
|
|
|
309 : |
|
|
id = freeProcesses->get();
|
310 : |
|
|
return id;
|
311 : |
|
|
}
|
312 : |
|
|
|
313 : |
|
|
}
|
314 : |
|
|
|
315 : |
|
|
void WorkLoadScheduler::sent(int procID) {
|
316 : |
|
|
if (procID < 0 || procID >= totalNumProc) {
|
317 : |
|
|
cerr << "Error in workloadscheduler - invalid process id " << procID << endl;
|
318 : |
|
|
exit(EXIT_FAILURE);
|
319 : |
|
|
}
|
320 : |
|
|
runInfo[procID]->startRun();
|
321 : |
|
|
}
|
322 : |
|
|
|
323 : |
|
|
int WorkLoadScheduler::quickHostsAvailable() {
|
324 : |
|
|
int available = 0, counter = 0;
|
325 : |
|
|
while (!(available) && counter < totalNumProc) {
|
326 : |
|
|
if ((!runInfo[counter]->isRunning()) && (procStat[counter] == 1))
|
327 : |
|
|
available = (runInfo[counter]->getRunTime() <= besttimeMultiple * bestTime);
|
328 : |
|
|
counter++;
|
329 : |
|
|
}
|
330 : |
|
|
|
331 : |
|
|
if (available == 1) {
|
332 : |
|
|
int tid = freeProcesses->get();
|
333 : |
|
|
while (tid != (counter - 1)) {
|
334 : |
|
|
freeProcesses->put(tid);
|
335 : |
|
|
tid = freeProcesses->get();
|
336 : |
|
|
}
|
337 : |
|
|
return tid;
|
338 : |
|
|
} else
|
339 : |
|
|
return -1;
|
340 : |
|
|
}
|
341 : |
|
|
|
342 : |
|
|
int WorkLoadScheduler::quickBusyProcesses() {
|
343 : |
|
|
int available = 0, counter = 0;
|
344 : |
|
|
while ((available == 0) && (counter < totalNumProc)) {
|
345 : |
|
|
if ((runInfo[counter]->isRunning() == 1) && (procStat[counter] == 1))
|
346 : |
|
|
available = ((runInfo[counter]->getRunTime()) <= besttimeMultiple * bestTime);
|
347 : |
|
|
counter++;
|
348 : |
|
|
}
|
349 : |
|
|
|
350 : |
|
|
if (available == 1)
|
351 : |
|
|
return 1;
|
352 : |
|
|
else
|
353 : |
|
|
return -1;
|
354 : |
|
|
}
|