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         if (hasVar) {
  48                 model_print("VarType1 %" PRIu64 ", ", type1);
  49                 model_print("VarType2 %" PRIu64 ", ", type2);
  50         }
  51         model_print("Param %s = %u \t range=[%u,%u]\n", tunableParameterToString( (Tunables)param), selectedValue, lowValue, highValue);
  52 }
  53
  54 unsigned int tunableSettingHash(TunableSetting *setting) {
  55         return setting->hasVar ^ setting->type1 ^ setting->type2 ^ setting->param;
  56 }
  57
  58 bool tunableSettingEquals(TunableSetting *setting1, TunableSetting *setting2) {
  59         return setting1->hasVar == setting2->hasVar &&
  60                                  setting1->type1 == setting2->type1 &&
  61                                  setting1->type2 == setting2->type2 &&
  62                                  setting1->param == setting2->param;
  63 }
  64
  65 ostream& operator<<(ostream& os, const TunableSetting& ts)
  66 {
  67     os << ts.hasVar <<" " << ts.type1 <<" " << ts.type2 << " " << ts.param << " " << ts.lowValue <<" "
  68             << ts.highValue << " " << ts.defaultValue << " " << ts.selectedValue;
  69     return os;
  70 }
  71
  72
  73 SearchTuner::SearchTuner() {
  74         ifstream myfile;
  75         myfile.open (TUNEFILE, ios::in);
  76         if(myfile.is_open()){
  77                 bool hasVar;
  78                 VarType type1;
  79                 VarType type2;
  80                 TunableParam param;
  81                 int lowValue;
  82                 int highValue;
  83                 int defaultValue;
  84                 int selectedValue;
  85                 while(myfile >> hasVar >> type1 >> type2 >> param >> lowValue >> highValue >> defaultValue >> selectedValue){
  86                         TunableSetting *setting;
  87
  88                         if(hasVar){
  89                                 setting = new TunableSetting(type1, type2, param);
  90                         }else{
  91                                 setting = new TunableSetting(param);
  92                         }
  93                         setting->setDecision(lowValue, highValue, defaultValue, selectedValue);
  94                         usedSettings.add(setting);
  95                 }
  96                 myfile.close();
  97         }
  98 }
  99
 100 SearchTuner *SearchTuner::copyUsed() {
 101         SearchTuner *tuner = new SearchTuner();
 102         SetIteratorTunableSetting *iterator = usedSettings.iterator();
 103         while (iterator->hasNext()) {
 104                 TunableSetting *setting = iterator->next();
 105                 TunableSetting *copy = new TunableSetting(setting);
 106                 tuner->settings.add(copy);
 107         }
 108         delete iterator;
 109         return tuner;
 110 }
 111
 112 SearchTuner::~SearchTuner() {
 113         SetIteratorTunableSetting *iterator = settings.iterator();
 114         while (iterator->hasNext()) {
 115                 TunableSetting *setting = iterator->next();
 116                 delete setting;
 117         }
 118         delete iterator;
 119 }
 120
 121 int SearchTuner::getTunable(TunableParam param, TunableDesc *descriptor) {
 122         TunableSetting setting(param);
 123         TunableSetting *result = usedSettings.get(&setting);
 124         if (result == NULL) {
 125                 result = settings.get(&setting);
 126                 if ( result == NULL) {
 127                         result = new TunableSetting(param);
 128                         uint value = descriptor->lowValue + (random() % (1 + descriptor->highValue - descriptor->lowValue));
 129                         result->setDecision(descriptor->lowValue, descriptor->highValue, descriptor->defaultValue, value);
 130                         settings.add(result);
 131                 }
 132                 usedSettings.add(result);
 133         }
 134         return result->selectedValue;
 135 }
 136
 137 int SearchTuner::getVarTunable(VarType vartype, TunableParam param, TunableDesc *descriptor) {
 138         return getVarTunable(vartype, 0, param, descriptor);
 139 }
 140
 141 int SearchTuner::getVarTunable(VarType vartype1, VarType vartype2, TunableParam param, TunableDesc *descriptor) {
 142         TunableSetting setting(vartype1, vartype2, param);
 143         TunableSetting *result = usedSettings.get(&setting);
 144         if (result == NULL) {
 145                 result = settings.get(&setting);
 146                 if ( result == NULL) {
 147                         result = new
 148                                                          TunableSetting(vartype1, vartype2, param);
 149                         uint value = descriptor->lowValue + (random() % (1 + descriptor->highValue - descriptor->lowValue));
 150                         result->setDecision(descriptor->lowValue, descriptor->highValue, descriptor->defaultValue, value);
 151                         settings.add(result);
 152                 }
 153                 usedSettings.add(result);
 154         }
 155         return result->selectedValue;
 156 }
 157
 158 void SearchTuner::randomMutate() {
 159         TunableSetting *randomSetting = settings.getRandomElement();
 160         int range = randomSetting->highValue - randomSetting->lowValue;
 161         int randomchoice = (random() % range) + randomSetting->lowValue;
 162         if (randomchoice < randomSetting->selectedValue)
 163                 randomSetting->selectedValue = randomchoice;
 164         else
 165                 randomSetting->selectedValue = randomchoice + 1;
 166 }
 167
 168 void SearchTuner::print() {
 169         SetIteratorTunableSetting *iterator = settings.iterator();
 170         while (iterator->hasNext()) {
 171                 TunableSetting *setting = iterator->next();
 172                 setting->print();
 173         }
 174         delete iterator;
 175
 176 }
 177
 178 void SearchTuner::serialize() {
 179         ofstream myfile;
 180         myfile.open (TUNEFILE, ios::out | ios::trunc);
 181         SetIteratorTunableSetting *iterator = settings.iterator();
 182         while (iterator->hasNext()) {
 183                 TunableSetting *setting = iterator->next();
 184                 myfile << *setting << endl;
 185         }
 186         myfile.close();
 187         delete iterator;
 188 }
 189
 190 void SearchTuner::printUsed() {
 191         SetIteratorTunableSetting *iterator = usedSettings.iterator();
 192         while (iterator->hasNext()) {
 193                 TunableSetting *setting = iterator->next();
 194                 setting->print();
 195         }
 196         delete iterator;
 197 }