src/Tuner/searchtuner.cc

   1 #include "searchtuner.h"
   2
   3 TunableSetting::TunableSetting(VarType _type, TunableParam _param) :
   4         hasVar(true),
   5         type1(_type),
   6         type2(0),
   7         param(_param) {
   8 }
   9
  10 TunableSetting::TunableSetting(VarType _type1, VarType _type2, TunableParam _param) :
  11         hasVar(true),
  12         type1(_type1),
  13         type2(_type2),
  14         param(_param) {
  15 }
  16
  17 TunableSetting::TunableSetting(TunableParam _param) :
  18         hasVar(false),
  19         type1(0),
  20         type2(0),
  21         param(_param) {
  22 }
  23
  24 TunableSetting::TunableSetting(TunableSetting *ts) :
  25         hasVar(ts->hasVar),
  26         type1(ts->type1),
  27         type2(ts->type2),
  28         param(ts->param),
  29         lowValue(ts->lowValue),
  30         highValue(ts->highValue),
  31         defaultValue(ts->defaultValue),
  32         selectedValue(ts->selectedValue)
  33 {
  34 }
  35
  36 void TunableSetting::setDecision(int _low, int _high, int _default, int _selection) {
  37         lowValue = _low;
  38         highValue = _high;
  39         defaultValue = _default;
  40         selectedValue = _selection;
  41 }
  42
  43 void TunableSetting::print() {
  44         if (hasVar) {
  45                 model_print("Type1 %" PRIu64 ", ", type1);
  46                 model_print("Type2 %" PRIu64 ", ", type2);
  47         }
  48         model_print("Param %u = %u\n", param, selectedValue);
  49 }
  50
  51 unsigned int tunableSettingHash(TunableSetting *setting) {
  52         return setting->hasVar ^ setting->type1 ^ setting->type2 ^ setting->param;
  53 }
  54
  55 bool tunableSettingEquals(TunableSetting *setting1, TunableSetting *setting2) {
  56         return setting1->hasVar == setting2->hasVar &&
  57                 setting1->type1 == setting2->type1 &&
  58                 setting1->type2 == setting2->type2 &&
  59                 setting1->param == setting2->param;
  60 }
  61
  62 SearchTuner::SearchTuner() {
  63 }
  64
  65 SearchTuner *SearchTuner::copyUsed() {
  66         SearchTuner *tuner = new SearchTuner();
  67         SetIteratorTunableSetting *iterator = usedSettings.iterator();
  68         while (iterator->hasNext()) {
  69                 TunableSetting *setting = iterator->next();
  70                 TunableSetting *copy = new TunableSetting(setting);
  71                 tuner->settings.add(copy);
  72         }
  73         delete iterator;
  74         return tuner;
  75 }
  76
  77 SearchTuner::~SearchTuner() {
  78         SetIteratorTunableSetting *iterator = settings.iterator();
  79         while (iterator->hasNext()) {
  80                 TunableSetting *setting = iterator->next();
  81                 delete setting;
  82         }
  83         delete iterator;
  84 }
  85
  86 int SearchTuner::getTunable(TunableParam param, TunableDesc *descriptor) {
  87         TunableSetting setting(param);
  88         TunableSetting *result = usedSettings.get(&setting);
  89         if (result == NULL) {
  90                 result = settings.get(&setting);
  91                 if ( result == NULL) {
  92                         result = new TunableSetting(param);
  93                         uint value = descriptor->lowValue + (random() % (1 + descriptor->highValue - descriptor->lowValue));
  94                         result->setDecision(descriptor->lowValue, descriptor->highValue, descriptor->defaultValue, value);
  95                         settings.add(result);
  96                 }
  97                 usedSettings.add(result);
  98         }
  99         return result->selectedValue;
 100 }
 101
 102 int SearchTuner::getVarTunable(VarType vartype, TunableParam param, TunableDesc *descriptor) {
 103         return getVarTunable(vartype, 0, param, descriptor);
 104 }
 105
 106 int SearchTuner::getVarTunable(VarType vartype1, VarType vartype2, TunableParam param, TunableDesc *descriptor) {
 107         TunableSetting setting(vartype1, vartype2, param);
 108         TunableSetting *result = usedSettings.get(&setting);
 109         if (result == NULL) {
 110                 result = settings.get(&setting);
 111                 if ( result == NULL) {
 112                         result = new
 113                                 TunableSetting(vartype1, vartype2, param);
 114                         uint value = descriptor->lowValue + (random() % (1 + descriptor->highValue - descriptor->lowValue));
 115                         result->setDecision(descriptor->lowValue, descriptor->highValue, descriptor->defaultValue, value);
 116                         settings.add(result);
 117                 }
 118                 usedSettings.add(result);
 119         }
 120         return result->selectedValue;
 121 }
 122
 123 void SearchTuner::randomMutate() {
 124         TunableSetting *randomSetting = settings.getRandomElement();
 125         int range = randomSetting->highValue - randomSetting->lowValue;
 126         int randomchoice = (random() % range) + randomSetting->lowValue;
 127         if (randomchoice < randomSetting->selectedValue)
 128                 randomSetting->selectedValue = randomchoice;
 129         else
 130                 randomSetting->selectedValue = randomchoice + 1;
 131 }
 132
 133 void SearchTuner::print() {
 134         SetIteratorTunableSetting *iterator = settings.iterator();
 135         while (iterator->hasNext()) {
 136                 TunableSetting *setting = iterator->next();
 137                 setting->print();
 138         }
 139         delete iterator;
 140
 141 }
 142
 143 void SearchTuner::printUsed() {
 144         SetIteratorTunableSetting *iterator = usedSettings.iterator();
 145         while (iterator->hasNext()) {
 146                 TunableSetting *setting = iterator->next();
 147                 setting->print();
 148         }
 149         delete iterator;
 150 }