common/h/tunableConst.h

   1 /*
   2  * Copyright (c) 1996-2009 Barton P. Miller
   3  *
   4  * We provide the Paradyn Parallel Performance Tools (below
   5  * described as "Paradyn") on an AS IS basis, and do not warrant its
   6  * validity or performance.  We reserve the right to update, modify,
   7  * or discontinue this software at any time.  We shall have no
   8  * obligation to supply such updates or modifications or any other
   9  * form of support to you.
  10  *
  11  * By your use of Paradyn, you understand and agree that we (or any
  12  * other person or entity with proprietary rights in Paradyn) are
  13  * under no obligation to provide either maintenance services,
  14  * update services, notices of latent defects, or correction of
  15  * defects for Paradyn.
  16  *
  17  * This library is free software; you can redistribute it and/or
  18  * modify it under the terms of the GNU Lesser General Public
  19  * License as published by the Free Software Foundation; either
  20  * version 2.1 of the License, or (at your option) any later version.
  21  *
  22  * This library is distributed in the hope that it will be useful,
  23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  25  * Lesser General Public License for more details.
  26  *
  27  * You should have received a copy of the GNU Lesser General Public
  28  * License along with this library; if not, write to the Free Software
  29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  30  */
  31 /*
  32  * tunableConstant - a constant that might be changed during execution.
  33  *
  34  * $Log: tunableConst.h,v $
  35  * Revision 1.10  1994/12/21 07:10:06  tamches
  36  * Made the "allConstants" variable protected and added a few member
  37  * functions to let outside code access it (safely) in a manner useful
  38  * for doing iterations through all tunable-constants.
  39  *
  40  * Revision 1.9  1994/12/21  00:31:44  tamches
  41  * Greatly cleaned up the interface; no data members are public any more.
  42  * Also some minor changes, such as using g++'s built-in "bool" instead
  43  * of "Boolean".
  44  *
  45  * Revision 1.8  1994/11/04  15:52:51  tamches
  46  * setValue() for boolean tc's now correctly invokes its callback function, if any.
  47  *
  48  * Revision 1.7  1994/11/01  16:07:35  markc
  49  * Added Object classes that provide os independent symbol tables.
  50  * Added stl-like container classes with iterators.
  51  *
  52  * Revision 1.6  1994/10/26  22:32:50  tamches
  53  * Defaulted min&max to 0 for floats with no min/max in constructor.
  54  * Wrote min() and max() functions.
  55  * Wrote use() function
  56  * other minor changes to get to work with new tclTunable code
  57  *
  58  * Revision 1.5  1994/09/22  03:15:59  markc
  59  * changed char* to const char *
  60  *
  61  * Revision 1.4  1994/08/05  16:01:55  hollings
  62  * More consistant use of stringHandle vs. char *.
  63  *
  64  * Revision 1.3  1994/08/03  18:37:30  hollings
  65  * split tunable constant into Boolean and Float sub-classes.
  66  *
  67  * Revision 1.2  1994/02/28  23:58:28  hollings
  68  * Changed global list to be a pointer to a list because I couldn't rely on
  69  * the order of global constructors.
  70  *
  71  * Revision 1.1  1994/02/25  00:25:58  hollings
  72  * added tunable constants.
  73  *
  74  *
  75  */
  76 #ifndef TUNABLE_CONST_H
  77 #define TUNABLE_CONST_H
  78
  79 #include <assert.h>
  80 #include "util/h/stringPool.h"
  81 #include "util/h/list.h"
  82
  83 typedef enum tunableUse { developerConstant, userConstant };
  84 typedef enum tunableType { tunableBoolean, tunableFloat };
  85
  86 //
  87 // Note: this is an abstract class, and can NOT be directly created.
  88 //
  89 class tunableConstant {
  90  protected:
  91    char *desc;
  92    char *name;
  93    tunableType typeName;
  94    tunableUse use;
  95
  96    static stringPool *pool; // made protected
  97
  98    static List<tunableConstant*> *allConstants; // NEEDS TO BE MADE PROTECTED
  99
 100  public:
 101    tunableConstant() {}
 102    virtual ~tunableConstant() {}
 103
 104    const char *getDesc() const {
 105       return desc;
 106    }
 107    const char *getName() const {
 108       return name;
 109    }
 110    tunableUse getUse() const {
 111       return use;
 112    }
 113    tunableType getType() const {
 114       return typeName;
 115    }
 116
 117    static tunableConstant *findTunableConstant(const char *name);
 118       // returns NULL if not found
 119
 120    static List<tunableConstant *> beginIteration() {
 121       assert(allConstants);
 122
 123       List <tunableConstant *> iterList = *allConstants;
 124          // make a copy of the list for iteration purposes
 125          // (actually, it just copies the head element, which itself
 126          // is merely a pointer)
 127
 128       return iterList;
 129    }
 130
 131    static int numTunables() {
 132       assert(allConstants);
 133       return allConstants->count();
 134    }
 135
 136    virtual void print() = NULL;
 137 };
 138
 139
 140 // Shouldn't the string pools be made part of the base class?
 141
 142 typedef bool (*isValidFunc)(float newVal);
 143 typedef void (*booleanChangeValCallBackFunc)(bool value);
 144 typedef void (*floatChangeValCallBackFunc)(float value);
 145
 146 class tunableBooleanConstant : public tunableConstant {
 147  private:
 148    bool value;
 149    booleanChangeValCallBackFunc newValueCallBack;
 150
 151  public:
 152
 153    tunableBooleanConstant(bool initialValue,
 154                           booleanChangeValCallBackFunc cb,
 155                           tunableUse type,
 156                           const char *name,
 157                           const char *desc);
 158    bool getValue() { return value; }
 159    bool setValue(bool newVal) {
 160       value = newVal;
 161       if (newValueCallBack)
 162          newValueCallBack(newVal);
 163       return true;
 164    }
 165
 166    virtual void print();
 167 };
 168
 169 class tunableFloatConstant : public tunableConstant {
 170  private:
 171    float value;
 172    float min, max;
 173    isValidFunc isValidValue;
 174
 175    floatChangeValCallBackFunc newValueCallBack;
 176    bool simpleRangeCheck(float val);
 177
 178  public:
 179
 180    tunableFloatConstant(float initialValue,
 181                         float min,
 182                         float max,
 183                         floatChangeValCallBackFunc cb,
 184                         tunableUse type,
 185                         const char *name,
 186                         const char *desc);
 187    tunableFloatConstant(float initialValue,
 188                         isValidFunc,
 189                         floatChangeValCallBackFunc cb,
 190                         tunableUse type,
 191                         const char *name,
 192                         const char *desc);
 193    float getValue() { return value; }
 194    bool setValue(float newVal) {
 195       if (isValidValue && isValidValue(newVal)) {
 196          value = newVal;
 197          if (newValueCallBack)
 198             newValueCallBack(newVal);
 199          return true;
 200       }
 201       else if (simpleRangeCheck(newVal)) {
 202          value = newVal;
 203          if (newValueCallBack)
 204             newValueCallBack(newVal);
 205          return true;
 206       }
 207       else
 208          return false;
 209    }
 210
 211    float getMin() {return min;}
 212    float getMax() {return max;}
 213
 214    virtual void print();
 215 };
 216
 217 #endif