src/Tuner/searchtuner.cc

   1 #include "searchtuner.h"
   2 #include "tunabledependent.h"
   3 #include <iostream>
   4 #include <fstream>
   5 #include <valarray>
   6 using namespace std;
   7
   8 HashsetTunableDep initializeTunableDependencies()
   9 {
  10   HashsetTunableDep dep;
  11   dep.add(new TunableDependent(MUSTREACHGLOBAL, DECOMPOSEORDER));
  12   dep.add(new TunableDependent(MUSTREACHLOCAL, DECOMPOSEORDER));
  13   dep.add(new TunableDependent(MUSTREACHPRUNE, DECOMPOSEORDER));
  14   dep.add(new TunableDependent(MUSTEDGEPRUNE, DECOMPOSEORDER));
  15   dep.add(new TunableDependent(NODEENCODING, ENCODINGGRAPHOPT));
  16   dep.add(new TunableDependent(EDGEENCODING, ENCODINGGRAPHOPT));
  17   dep.add(new TunableDependent(ELEMENTOPTSETS, ELEMENTOPT));
  18   return dep;
  19 }
  20
  21
  22 HashsetTunableDep SearchTuner::tunableDependency = initializeTunableDependencies();
  23
  24 TunableSetting::TunableSetting(VarType _type, TunableParam _param) :
  25         hasVar(true),
  26         type1(_type),
  27         type2(0),
  28         param(_param) {
  29 }
  30
  31 TunableSetting::TunableSetting(VarType _type1, VarType _type2, TunableParam _param) :
  32         hasVar(true),
  33         type1(_type1),
  34         type2(_type2),
  35         param(_param) {
  36 }
  37
  38 TunableSetting::TunableSetting(TunableParam _param) :
  39         hasVar(false),
  40         type1(0),
  41         type2(0),
  42         param(_param) {
  43 }
  44
  45 TunableSetting::TunableSetting(TunableSetting *ts) :
  46         hasVar(ts->hasVar),
  47         type1(ts->type1),
  48         type2(ts->type2),
  49         param(ts->param),
  50         lowValue(ts->lowValue),
  51         highValue(ts->highValue),
  52         defaultValue(ts->defaultValue),
  53         selectedValue(ts->selectedValue)
  54 {
  55 }
  56
  57 void TunableSetting::setDecision(int _low, int _high, int _default, int _selection) {
  58         lowValue = _low;
  59         highValue = _high;
  60         defaultValue = _default;
  61         selectedValue = _selection;
  62 }
  63
  64 void TunableSetting::print() {
  65         model_print("Param %s = %u \t range=[%u,%u]", tunableParameterToString( (Tunables)param), selectedValue, lowValue, highValue);
  66         if (hasVar) {
  67                 model_print("\tVarType1 %" PRIu64 ", ", type1);
  68                 model_print("VarType2 %" PRIu64 ", ", type2);
  69         }
  70         model_print("\n");
  71 }
  72
  73 unsigned int tunableSettingHash(TunableSetting *setting) {
  74         return setting->hasVar ^ setting->type1 ^ setting->type2 ^ setting->param;
  75 }
  76
  77 bool tunableSettingEquals(TunableSetting *setting1, TunableSetting *setting2) {
  78         return setting1->hasVar == setting2->hasVar &&
  79                                  setting1->type1 == setting2->type1 &&
  80                                  setting1->type2 == setting2->type2 &&
  81                                  setting1->param == setting2->param;
  82 }
  83
  84 ostream &operator<<(ostream &os, const TunableSetting &ts)
  85 {
  86         os << ts.hasVar << " " << ts.type1 << " " << ts.type2 << " " << ts.param << " " << ts.lowValue << " "
  87                  << ts.highValue << " " << ts.defaultValue << " " << ts.selectedValue;
  88         return os;
  89 }
  90
  91
  92 SearchTuner::SearchTuner() {
  93 #ifdef STATICENCGEN
  94         graphEncoding =false;
  95         naiveEncoding = ELEM_UNASSIGNED;
  96 #endif
  97         ifstream myfile;
  98         myfile.open (TUNEFILE, ios::in);
  99         if (myfile.is_open()) {
 100                 bool hasVar;
 101                 VarType type1;
 102                 VarType type2;
 103                 TunableParam param;
 104                 int lowValue;
 105                 int highValue;
 106                 int defaultValue;
 107                 int selectedValue;
 108                 while (myfile >> hasVar >> type1 >> type2 >> param >> lowValue >> highValue >> defaultValue >> selectedValue) {
 109                         TunableSetting *setting;
 110
 111                         if (hasVar) {
 112                                 setting = new TunableSetting(type1, type2, param);
 113                         } else {
 114                                 setting = new TunableSetting(param);
 115                         }
 116                         setting->setDecision(lowValue, highValue, defaultValue, selectedValue);
 117                         usedSettings.add(setting);
 118                 }
 119                 myfile.close();
 120         }
 121 }
 122
 123 SearchTuner *SearchTuner::copyUsed() {
 124         SearchTuner *tuner = new SearchTuner();
 125         SetIteratorTunableSetting *iterator = usedSettings.iterator();
 126         while (iterator->hasNext()) {
 127                 TunableSetting *setting = iterator->next();
 128                 TunableSetting *copy = new TunableSetting(setting);
 129                 tuner->settings.add(copy);
 130         }
 131 #ifdef STATICENCGEN
 132         if(naiveEncoding != ELEM_UNASSIGNED){
 133                 tuner->graphEncoding = graphEncoding;
 134                 tuner->naiveEncoding = naiveEncoding;
 135         }
 136 #endif
 137         delete iterator;
 138         return tuner;
 139 }
 140
 141 SearchTuner::~SearchTuner() {
 142         SetIteratorTunableSetting *iterator = settings.iterator();
 143         while (iterator->hasNext()) {
 144                 TunableSetting *setting = iterator->next();
 145                 delete setting;
 146         }
 147         delete iterator;
 148 }
 149
 150 int SearchTuner::getTunable(TunableParam param, TunableDesc *descriptor) {
 151         TunableSetting setting(param);
 152         TunableSetting *result = usedSettings.get(&setting);
 153         if (result == NULL) {
 154                 result = settings.get(&setting);
 155                 if ( result == NULL) {
 156                         result = new TunableSetting(param);
 157                         uint value = descriptor->lowValue + (random() % (1 + descriptor->highValue - descriptor->lowValue));
 158                         result->setDecision(descriptor->lowValue, descriptor->highValue, descriptor->defaultValue, value);
 159                         settings.add(result);
 160                 }
 161                 usedSettings.add(result);
 162         }
 163         return result->selectedValue;
 164 }
 165
 166 int SearchTuner::getVarTunable(VarType vartype, TunableParam param, TunableDesc *descriptor) {
 167         return getVarTunable(vartype, 0, param, descriptor);
 168 }
 169
 170 int SearchTuner::getVarTunable(VarType vartype1, VarType vartype2, TunableParam param, TunableDesc *descriptor) {
 171         TunableSetting setting(vartype1, vartype2, param);
 172         TunableSetting *result = usedSettings.get(&setting);
 173         if (result == NULL) {
 174                 result = settings.get(&setting);
 175                 if ( result == NULL) {
 176                         result = new
 177                                                          TunableSetting(vartype1, vartype2, param);
 178                         uint value = descriptor->lowValue + (random() % (1 + descriptor->highValue - descriptor->lowValue));
 179                         result->setDecision(descriptor->lowValue, descriptor->highValue, descriptor->defaultValue, value);
 180                         settings.add(result);
 181                 }
 182                 usedSettings.add(result);
 183         }
 184         return result->selectedValue;
 185 }
 186
 187 bool SearchTuner::validTunableSetting(TunableSetting* setting){
 188         TunableDependent tuneDep((Tunables)setting->param);
 189         bool result = true;
 190         while(tunableDependency.contains(&tuneDep)){
 191                 TunableDependent *dependent = tunableDependency.get(&tuneDep);
 192                 TunableSetting p(dependent->parent);
 193                 if(!settings.contains(&p)){
 194                         SetIteratorTunableSetting *iter = settings.iterator();
 195                         while(iter->hasNext()){
 196                                 model_print("*******************\n");
 197                                 iter->next()->print();
 198                         }
 199                         delete iter;
 200                 }
 201                 ASSERT(settings.contains(&p));
 202                 TunableSetting *parent = settings.get(&p);
 203                 if(!(bool)parent->selectedValue){ //Check parent config is already off
 204                         return false;
 205                 }
 206                 tuneDep.dependent = dependent->parent;
 207         }
 208         return result;
 209 }
 210
 211 void SearchTuner::randomMutate() {
 212         TunableSetting *randomSetting;
 213         do{
 214                 randomSetting= settings.getRandomElement();
 215         }while(!validTunableSetting(randomSetting));
 216         int range = randomSetting->highValue - randomSetting->lowValue;
 217         int randomchoice = (random() % range) + randomSetting->lowValue;
 218         if (randomchoice < randomSetting->selectedValue)
 219                 randomSetting->selectedValue = randomchoice;
 220         else
 221                 randomSetting->selectedValue = randomchoice + 1;
 222         model_print("&&&&&&&&Mutating&&&&&&&\n");
 223         randomSetting->print();
 224         model_print("&&&&&&&&&&&&&&&&&&&&&&&\n");
 225 }
 226
 227 #ifdef STATICENCGEN
 228 int SearchTuner::nextStaticTuner() {
 229         if(naiveEncoding == ELEM_UNASSIGNED){
 230                 naiveEncoding = ONEHOT;
 231                 SetIteratorTunableSetting *iter = settings.iterator();
 232                 while(iter->hasNext()){
 233                         TunableSetting *setting = iter->next();
 234                         if (setting->param == NAIVEENCODER){
 235                                 setting->selectedValue = ONEHOT;
 236                         } else if(setting->param == ENCODINGGRAPHOPT){
 237                                 setting->selectedValue = false;
 238                         }
 239                 }
 240                 delete iter;
 241                 return EXIT_FAILURE;
 242         }
 243         int result=EXIT_FAILURE;
 244         if(naiveEncoding == BINARYINDEX && graphEncoding){
 245                 model_print("Best tuner\n");
 246                 return EXIT_SUCCESS;
 247         }else if (naiveEncoding == BINARYINDEX && !graphEncoding){
 248                 naiveEncoding = ONEHOT;
 249                 graphEncoding = true;
 250         }else {
 251                 naiveEncoding = (ElementEncodingType)((int)naiveEncoding + 1);
 252         }
 253         SetIteratorTunableSetting *iter = settings.iterator();
 254         uint count = 0;
 255         while(iter->hasNext()){
 256                 TunableSetting * setting = iter->next();
 257                 if (setting->param == NAIVEENCODER){
 258                         setting->selectedValue = naiveEncoding;
 259                         count++;
 260                 } else if(setting->param == ENCODINGGRAPHOPT){
 261                         setting->selectedValue = graphEncoding;
 262                         count++;
 263                 }
 264         }
 265         model_print("Mutating %u settings\n", count);
 266         delete iter;
 267         return result;
 268 }
 269 #endif
 270
 271 void SearchTuner::print() {
 272         SetIteratorTunableSetting *iterator = settings.iterator();
 273         while (iterator->hasNext()) {
 274                 TunableSetting *setting = iterator->next();
 275                 setting->print();
 276         }
 277         delete iterator;
 278
 279 }
 280
 281 void SearchTuner::serialize() {
 282         ofstream myfile;
 283         myfile.open (TUNEFILE, ios::out | ios::trunc);
 284         SetIteratorTunableSetting *iterator = settings.iterator();
 285         while (iterator->hasNext()) {
 286                 TunableSetting *setting = iterator->next();
 287                 myfile << *setting << endl;
 288         }
 289         myfile.close();
 290         delete iterator;
 291 }
 292
 293 void SearchTuner::printUsed() {
 294         SetIteratorTunableSetting *iterator = usedSettings.iterator();
 295         while (iterator->hasNext()) {
 296                 TunableSetting *setting = iterator->next();
 297                 setting->print();
 298         }
 299         delete iterator;
 300 }