Fixing silent bug for not finding the tuner
[satune.git] / src / Tuner / basictuner.cc
1 /*
2  * To change this license header, choose License Headers in Project Properties.
3  * To change this template file, choose Tools | Templates
4  * and open the template in the editor.
5  */
6
7 /*
8  * File:   basictuner.cc
9  * Author: hamed
10  *
11  * Created on December 17, 2018, 2:02 PM
12  */
13
14 #include "basictuner.h"
15 #include "common.h"
16 #include "csolver.h"
17 #include "searchtuner.h"
18 #include <stdlib.h>
19 #include <string.h>
20 #include <iostream>
21 #include <fstream>
22
23 Problem::Problem(const char *_problem) :
24         problemnumber(-1),
25         result(TUNERUNSETVALUE),
26         besttime(LLONG_MAX)
27 {
28         uint len = strlen(_problem);
29         problem = (char *) ourmalloc(len + 1);
30         memcpy(problem, _problem, len + 1);
31 }
32
33 Problem::~Problem() {
34         ourfree(problem);
35 }
36
37 void TunerRecord::setTime(Problem *problem, long long time) {
38         timetaken.put(problem, time);
39 }
40
41 void TunerRecord::print() {
42         model_print("*************TUNER NUMBER=%d***********\n", tunernumber);
43         tuner->print();
44         model_print("&&&&&&&&&&&&&USED SETTINGS &&&&&&&&&&&&\n");
45         tuner->printUsed();
46         model_print("\n");
47 }
48
49 void TunerRecord::printProblemsInfo() {
50         for (uint j = 0; j < problems.getSize(); j++) {
51                 Problem *problem = problems.get(j);
52                 model_print("Problem %s\n", problem->getProblem());
53                 model_print("Time = %lld\n", getTime(problem));
54         }
55 }
56
57 long long TunerRecord::getTime(Problem *problem) {
58         if (timetaken.contains(problem))
59                 return timetaken.get(problem);
60         else return -1;
61 }
62
63 TunerRecord *TunerRecord::changeTuner(SearchTuner *_newtuner) {
64         TunerRecord *tr = new TunerRecord(_newtuner);
65         for (uint i = 0; i < problems.getSize(); i++) {
66                 tr->problems.push(problems.get(i));
67         }
68         return tr;
69 }
70
71
72 BasicTuner::BasicTuner(uint _budget, uint _timeout) :
73         budget(_budget), timeout(_timeout), execnum(0) {
74 }
75
76 BasicTuner::~BasicTuner() {
77         for (uint i = 0; i < problems.getSize(); i++)
78                 ourfree(problems.get(i));
79         for (uint i = 0; i < allTuners.getSize(); i++)
80                 delete allTuners.get(i);
81 }
82
83 void BasicTuner::addProblem(const char *filename) {
84         Problem *p = new Problem(filename);
85         p->setProblemNumber(problems.getSize());
86         problems.push(p);
87 }
88
89 void BasicTuner::printData() {
90         model_print("*********** DATA DUMP ***********\n");
91         for (uint i = 0; i < allTuners.getSize(); i++) {
92                 TunerRecord *tuner = allTuners.get(i);
93                 SearchTuner *stun = tuner->getTuner();
94                 model_print("Tuner %u\n", i);
95                 stun->print();
96                 model_print("----------------------------------\n\n\n");
97                 for (uint j = 0; j < tuner->problemsSize(); j++) {
98                         Problem *problem = tuner->getProblem(j);
99                         model_print("Problem %s\n", problem->getProblem());
100                         model_print("Time = %lld\n", tuner->getTime(problem));
101                 }
102         }
103 }
104
105 bool BasicTuner::tunerExists(TunerRecord *tunerec) {
106         SearchTuner *tuner = tunerec->getTuner();
107         for (uint i = 0; i < explored.getSize(); i++) {
108                 if (explored.get(i)->getTuner()->equalUsed(tuner)) {
109                         model_print("************Tuner <%d> is replicate of Tuner <%d>\n", tunerec->getTunerNumber(), explored.get(i)->getTunerNumber());
110                         return true;
111                 }
112         }
113         return false;
114 }
115
116 void BasicTuner::addTuner(SearchTuner *tuner) {
117         TunerRecord *t = new TunerRecord(tuner);
118         tuners.push(t);
119         t->setTunerNumber( allTuners.getSize() );
120         allTuners.push(t);
121 }
122
123 long long BasicTuner::evaluate(Problem *problem, TunerRecord *tuner) {
124         char buffer[512];
125         {
126                 snprintf(buffer, sizeof(buffer), "problem%u", execnum);
127
128                 ofstream myfile;
129                 myfile.open (buffer, ios::out);
130
131
132                 if (myfile.is_open()) {
133                         myfile << problem->getProblem() << endl;
134                         myfile << problem->getProblemNumber() << endl;
135                         myfile.close();
136                 }
137         }
138
139         {
140                 snprintf(buffer, sizeof(buffer), "tunernum%u", execnum);
141
142                 ofstream myfile;
143                 myfile.open (buffer, ios::out);
144
145
146                 if (myfile.is_open()) {
147                         myfile << tuner->getTunerNumber() << endl;
148                         myfile.close();
149                 }
150         }
151
152         //Write out the tuner
153         snprintf(buffer, sizeof(buffer), "tuner%u", execnum);
154         tuner->getTuner()->serialize(buffer);
155
156         //compute timeout
157         uint timeinsecs = problem->getBestTime() / NANOSEC;
158         uint adaptive = (timeinsecs > 30) ? timeinsecs * 5 : 150;
159         uint maxtime = (adaptive < timeout) ? adaptive : timeout;
160         uint satuneTimeout = 2 * maxtime;
161         //Do run
162         snprintf(buffer, sizeof(buffer), "timeout %u ./run.sh deserializerun %s %u tuner%u result%u > log%u", satuneTimeout, problem->getProblem(), maxtime, execnum, execnum, execnum);
163         model_print("Running: %s\n", buffer);
164         int status = system(buffer);
165
166         long long metric = -1;
167         int sat = IS_INDETER;
168
169         if (status == 0) {
170                 //Read data in from results file
171                 snprintf(buffer, sizeof(buffer), "result%u", execnum);
172
173                 ifstream myfile;
174                 myfile.open (buffer, ios::in);
175
176
177                 if (myfile.is_open()) {
178                         myfile >> metric;
179                         myfile >> sat;
180                         myfile.close();
181                 }
182                 updateTimeout(problem, metric);
183                 snprintf(buffer, sizeof(buffer), "tuner%uused", execnum);
184                 tuner->getTuner()->addUsed(buffer);
185         } else if (status == 124 << 8) {// timeout happens ...
186                 tuner->getTuner()->copySettingstoUsedSettings();
187         }
188
189         //Increment execution count
190         execnum++;
191
192         if (problem->getResult() == TUNERUNSETVALUE && sat != IS_INDETER) {
193                 problem->setResult( sat );
194         } else if (problem->getResult() != sat && sat != IS_INDETER) {
195                 model_print("******** Result has changed ********\n");
196         }
197         if (sat == IS_INDETER && metric != -1) {//The case when we have a timeout
198                 metric = -1;
199         }
200         return metric;
201 }
202
203 SearchTuner *BasicTuner::mutateTuner(SearchTuner *oldTuner, uint k) {
204         SearchTuner *newTuner = oldTuner->copyUsed();
205         uint numSettings = oldTuner->getSize();
206         uint settingsToMutate = (uint)(AUTOTUNERFACTOR * (((double)numSettings) * (budget - k)) / (budget));
207         if (settingsToMutate < 1)
208                 settingsToMutate = 1;
209         model_print("Mutating %u settings\n", settingsToMutate);
210         while (settingsToMutate-- != 0) {
211                 newTuner->randomMutate();
212         }
213         return newTuner;
214 }
215
216 int BasicTuner::subTunerIndex(SearchTuner *newTuner) {
217         for (uint i = 0; i < explored.getSize(); i++) {
218                 SearchTuner *tuner = explored.get(i)->getTuner();
219                 if (tuner->isSubTunerof(newTuner)) {
220                         return i;
221                 }
222         }
223         return -1;
224 }
225
226
227 void BasicTuner::updateTimeout(Problem *problem, long long metric) {
228         if (metric < problem->getBestTime()) {
229                 problem->setBestTime( metric );
230         }
231 }