src/Tuner/randomtuner.cc

   1 #include "randomtuner.h"
   2 #include "csolver.h"
   3 #include "searchtuner.h"
   4 #include "multituner.h"
   5 #include <math.h>
   6 #include <stdlib.h>
   7 #include <float.h>
   8 #include <string.h>
   9 #include <iostream>
  10 #include <fstream>
  11 #include <limits>
  12
  13 #define UNSETVALUE -1
  14
  15 RandomTuner::RandomTuner(uint _budget, uint _timeout) :
  16         budget(_budget), timeout(_timeout), execnum(0) {
  17 }
  18
  19 RandomTuner::~RandomTuner() {
  20         for (uint i = 0; i < problems.getSize(); i++)
  21                 ourfree(problems.get(i));
  22         for (uint i = 0; i < allTuners.getSize(); i++)
  23                 delete allTuners.get(i);
  24 }
  25
  26 void RandomTuner::addProblem(const char *filename) {
  27         Problem *p = new Problem(filename);
  28         p->problemnumber = problems.getSize();
  29         problems.push(p);
  30 }
  31
  32 void RandomTuner::printData() {
  33         model_print("*********** DATA DUMP ***********\n");
  34         for (uint i = 0; i < allTuners.getSize(); i++) {
  35                 TunerRecord *tuner = allTuners.get(i);
  36                 SearchTuner *stun = tuner->getTuner();
  37                 model_print("Tuner %u\n", i);
  38                 stun->print();
  39                 model_print("----------------------------------\n\n\n");
  40                 for (uint j = 0; j < tuner->problems.getSize(); j++) {
  41                         Problem *problem = tuner->problems.get(j);
  42                         model_print("Problem %s\n", problem->getProblem());
  43                         model_print("Time = %lld\n", tuner->getTime(problem));
  44                 }
  45         }
  46 }
  47
  48 bool RandomTuner::tunerExists(SearchTuner *tuner){
  49         for(uint i=0; i< explored.getSize(); i++){
  50                 if(explored.get(i)->getTuner()->equalUsed(tuner))
  51                         return true;
  52         }
  53         return false;
  54 }
  55
  56 void RandomTuner::addTuner(SearchTuner *tuner) {
  57         TunerRecord *t = new TunerRecord(tuner);
  58         tuners.push(t);
  59         t->tunernumber = allTuners.getSize();
  60         allTuners.push(t);
  61 }
  62
  63 long long RandomTuner::evaluate(Problem *problem, TunerRecord *tuner) {
  64         char buffer[512];
  65         {
  66                 snprintf(buffer, sizeof(buffer), "problem%u", execnum);
  67
  68                 ofstream myfile;
  69                 myfile.open (buffer, ios::out);
  70
  71
  72                 if (myfile.is_open()) {
  73                         myfile << problem->getProblem() << endl;
  74                         myfile << problem->problemnumber << endl;
  75                         myfile.close();
  76                 }
  77         }
  78
  79         {
  80                 snprintf(buffer, sizeof(buffer), "tunernum%u", execnum);
  81
  82                 ofstream myfile;
  83                 myfile.open (buffer, ios::out);
  84
  85
  86                 if (myfile.is_open()) {
  87                         myfile << tuner->tunernumber << endl;
  88                         myfile.close();
  89                 }
  90         }
  91
  92         //Write out the tuner
  93         snprintf(buffer, sizeof(buffer), "tuner%u", execnum);
  94         tuner->getTuner()->serialize(buffer);
  95
  96         //compute timeout
  97         uint timeinsecs = problem->besttime / NANOSEC;
  98         uint adaptive = (timeinsecs > 30) ? timeinsecs * 5 : 150;
  99         uint maxtime = (adaptive < timeout) ? adaptive : timeout;
 100
 101         //Do run
 102         snprintf(buffer, sizeof(buffer), "./run.sh deserializerun %s %u tuner%u result%u > log%u", problem->getProblem(), maxtime, execnum, execnum, execnum);
 103         int status = system(buffer);
 104
 105         long long metric = -1;
 106         int sat = IS_INDETER;
 107
 108         if (status == 0) {
 109                 //Read data in from results file
 110                 snprintf(buffer, sizeof(buffer), "result%u", execnum);
 111
 112                 ifstream myfile;
 113                 myfile.open (buffer, ios::in);
 114
 115
 116                 if (myfile.is_open()) {
 117                         myfile >> metric;
 118                         myfile >> sat;
 119                         myfile.close();
 120                 }
 121                 updateTimeout(problem, metric);
 122                 snprintf(buffer, sizeof(buffer), "tuner%uused", execnum);
 123                 tuner->getTuner()->addUsed(buffer);
 124         }
 125         //Increment execution count
 126         execnum++;
 127
 128         if (problem->result == UNSETVALUE && sat != IS_INDETER) {
 129                 problem->result = sat;
 130         } else if (problem->result != sat && sat != IS_INDETER) {
 131                 model_print("******** Result has changed ********\n");
 132         }
 133         if (sat == IS_INDETER && metric != -1) {//The case when we have a timeout
 134                 metric = -1;
 135         }
 136         return metric;
 137 }
 138
 139 void RandomTuner::updateTimeout(Problem *problem, long long metric) {
 140         if (metric < problem->besttime) {
 141                 problem->besttime = metric;
 142         }
 143 }
 144
 145 void RandomTuner::tune() {
 146         for (uint r = 0; r < budget; r++) {
 147                 model_print("Round %u of %u\n", r, budget);
 148                 for (uint i = 0; i < tuners.getSize(); i++){
 149                         TunerRecord *tuner = tuners.get(i);
 150                         bool isNew = true;
 151                         for (uint j = 0; j < problems.getSize(); j++){
 152                                 Problem *problem = problems.get(j);
 153                                 long long metric = tuner->getTime(problem);
 154                                 if(metric == -1){
 155                                         metric = evaluate(problem, tuner);
 156                                         ASSERT(tuner->getTime(problem) == -1);
 157                                         tuner->problems.push(problem);
 158                                         model_print("%u.Problem<%s>\tTuner<%p, %d>\tMetric<%lld>\n", i, problem->problem,tuner, tuner->tunernumber, metric);
 159                                         if (metric != -1)
 160                                                 tuner->setTime(problem, metric);
 161                                         else
 162                                                 tuner->setTime(problem, -2);
 163                                         if(tunerExists(tuner->getTuner())){
 164                                                 //Solving the first problem and noticing the tuner
 165                                                 //already exists
 166                                                 isNew = false;
 167                                                 break;
 168                                         }
 169                                 }
 170                         }
 171                         if(isNew){
 172                                 explored.push(tuner);
 173                         }
 174
 175                 }
 176                 uint tSize = tuners.getSize();
 177                 for (uint i = 0; i < tSize; i++) {
 178                         SearchTuner *tmpTuner = mutateTuner(tuners.get(i)->getTuner(), budget);
 179                         while(subtuneIndex(tmpTuner) != -1){
 180                                 tmpTuner->randomMutate();
 181                         }
 182                         TunerRecord *tmp = new TunerRecord(tmpTuner);
 183                         tmp->tunernumber = allTuners.getSize();
 184                         model_print("Mutated tuner %u to generate tuner %u\n", tuners.get(i)->tunernumber, tmp->tunernumber);
 185                         allTuners.push(tmp);
 186                         tuners.set(i, tmp);
 187                 }
 188         }
 189         printData();
 190
 191 }
 192
 193 SearchTuner *RandomTuner::mutateTuner(SearchTuner *oldTuner, uint k) {
 194         SearchTuner *newTuner = oldTuner->copyUsed();
 195         uint numSettings = oldTuner->getSize();
 196         uint settingsToMutate = (uint)(AUTOTUNERFACTOR * (((double)numSettings) * (budget - k)) / (budget));
 197         if (settingsToMutate < 1)
 198                 settingsToMutate = 1;
 199         model_print("Mutating %u settings\n", settingsToMutate);
 200         while (settingsToMutate-- != 0) {
 201                 newTuner->randomMutate();
 202         }
 203         return newTuner;
 204 }
 205
 206 int RandomTuner::subtuneIndex(SearchTuner *newTuner){
 207         for (uint i=0; i< explored.getSize(); i++){
 208                 SearchTuner *tuner = explored.get(i)->getTuner();
 209                 if(tuner->isSubTunerof(newTuner)){
 210                         return i;
 211                 }
 212         }
 213         return -1;
 214 }