src/Tuner/searchtuner.cc

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