paradynd/src/metricFocusNode.h

   1 /*
   2  *  Copyright 1993 Jeff Hollingsworth.  All rights reserved.
   3  *
   4  */
   5
   6 /*
   7  * metric.h
   8  *
   9  * $Log: metricFocusNode.h,v $
  10  * Revision 1.2  1994/03/24 16:42:01  hollings
  11  * Moved sample aggregation to lib/util (so paradyn could use it).
  12  *
  13  * Revision 1.1  1994/01/27  20:31:29  hollings
  14  * Iinital version of paradynd speaking dynRPC igend protocol.
  15  *
  16  * Revision 1.9  1994/01/20  17:48:13  hollings
  17  * dataReqNode overcome by events.
  18  *
  19  * Revision 1.8  1993/10/19  15:27:54  hollings
  20  * AST based mini-tramp code generator.
  21  *
  22  * Revision 1.7  1993/10/01  21:29:41  hollings
  23  * Added resource discovery and filters.
  24  *
  25  * Revision 1.6  1993/08/20  22:01:51  hollings
  26  * added getMetricValue and returnCounterInstance.
  27  *
  28  * Revision 1.5  1993/08/11  01:52:55  hollings
  29  * new build before use metrics.
  30  *
  31  * Revision 1.4  1993/06/22  19:00:01  hollings
  32  * global inst state.
  33  *
  34  * Revision 1.3  1993/06/08  20:14:34  hollings
  35  * state prior to bc net ptrace replacement.
  36  *
  37  * Revision 1.2  1993/04/27  14:39:21  hollings
  38  * signal forwarding and args tramp.
  39  *
  40  * Revision 1.1  1993/03/19  22:51:05  hollings
  41  * Initial revision
  42  *
  43  *
  44  */
  45
  46 #include "dyninstRPC.h"
  47 #include "util/h/aggregateSample.h"
  48
  49 /*
  50  * internal representation of an inst. request.
  51  *
  52  */
  53 typedef enum { intCounter, timer } dataObjectType;
  54
  55 class AstNode;
  56 class metricDefinitionNode;
  57
  58 class dataReqNode {
  59     public:
  60         dataReqNode(dataObjectType, process*, int, Boolean iReport, timerType);
  61         ~dataReqNode();
  62         float getMetricValue();
  63         float cost();
  64         void insertInstrumentation(metricDefinitionNode *mi);
  65         void disable();
  66
  67         // return a pointer in the inferrior address space of this data object.
  68         void *getInferriorPtr();
  69         intCounterHandle *returnCounterInstance() {
  70             return((intCounterHandle *) instance);
  71         }
  72         int getSampleId()       { return(id.id); }
  73         dataObjectType getType() { return(type); }
  74
  75     private:
  76         timerHandle *createTimerInstance();
  77         intCounterHandle *createCounterInstance();
  78
  79         dataObjectType  type;
  80         process         *proc;
  81         int             initialValue;
  82         Boolean         report;
  83         timerType       tType;
  84         sampleId        id;     // unique id for this sample
  85
  86         void            *instance;
  87 };
  88
  89 class instReqNode {
  90     public:
  91         instReqNode(process*, instPoint*, AstNode*, callWhen, callOrder order);
  92         ~instReqNode();
  93
  94         Boolean insertInstrumentation();
  95         void disable();
  96         float cost();
  97
  98     private:
  99         process         *proc;
 100         instPoint       *point;
 101         AstNode         *ast;
 102         callWhen        when;
 103         callOrder       order;
 104         instInstance    *instance;
 105 };
 106
 107 #ifdef notdef
 108 struct sampleInfo {
 109     Boolean firstSampleReceived;        /* has first sample been recoreded */
 110     sampleValue value;                  /* cumlative value */
 111     timeStamp   lastSampleStart;        /* start time for last sample */
 112     timeStamp   lastSampleEnd;          /* end time for last sample */
 113     sampleValue lastSample;             /* what was the last sample increment */
 114 };
 115 #endif
 116
 117 class metricDefinitionNode {
 118     public:
 119         metricDefinitionNode(process *p);
 120         metricDefinitionNode(metric m, List<metricDefinitionNode*> parts);
 121         ~metricDefinitionNode();
 122         void disable();
 123         void updateValue(time64, sampleValue);
 124
 125         Boolean match(resourceList l, metric m) {
 126             return(resList == l && met == m);
 127         }
 128         Boolean insertInstrumentation();
 129         float cost();
 130         // used by controller.
 131         float getMetricValue();
 132         dataReqNode *addIntCounter(int inititalValue, Boolean report) {
 133             dataReqNode *tp;
 134
 135             tp = new dataReqNode(intCounter, proc, inititalValue,
 136                 report,processTime);
 137             data.add(tp);
 138             return(tp);
 139         };
 140         dataReqNode *addTimer(timerType type) {
 141             dataReqNode *tp;
 142             tp = new dataReqNode(timer,proc,0,True,type);
 143             data.add(tp);
 144             return(tp);
 145         };
 146         void addInst(instPoint *point,AstNode *ast, callWhen when, callOrder o){
 147             instReqNode *temp;
 148             temp = new instReqNode(proc, point, ast, when, o);
 149             requests.add(temp);
 150         };
 151
 152         int id;                         // unique id for this one
 153         metric met;                     // what type of metric
 154         resourceList resList;           // what resource list is this for.
 155
 156         // is this a final value or a component of a larger metric.
 157         Boolean inform;
 158
 159         process                 *proc;
 160     private:
 161         void updateAggregateComponent(metricDefinitionNode *,
 162                                       time64 time, sampleValue value);
 163
 164         Boolean                 aggregate;
 165         Boolean                 inserted;
 166
 167         /* for aggregate metrics */
 168         List<metricDefinitionNode*>   components;
 169
 170         /* for non-aggregate metrics */
 171         List<dataReqNode*>      data;
 172         List<instReqNode*>      requests;
 173
 174         // which metricDefinitionNode depend on this value.
 175         List<metricDefinitionNode*>   aggregators;
 176
 177 #ifdef notdef
 178         struct sampleInfo       sampleData;     /* actual data */
 179 #endif
 180         List<sampleInfo*>       valueList;      // actual data for comp.
 181         sampleInfo sample;
 182 };
 183
 184 typedef AstNode *(*createPredicateFunc)(metricDefinitionNode *mn,
 185     char *resource, AstNode *trigger);
 186
 187 typedef void (*createMetricFunc)(metricDefinitionNode*, AstNode *trigger);
 188
 189 typedef struct {
 190     createPredicateFunc creator;
 191 } predicateDefinition;
 192
 193 typedef enum { invalidPredicate,
 194                nullPredicate,
 195                simplePredicate,
 196                replaceBase } predicateType;
 197
 198 typedef struct {
 199     char *namePrefix;                   /* leading part of resource path */
 200     predicateType       type;
 201     createPredicateFunc creator;        /* create a metric */
 202 } resourcePredicate;
 203
 204 typedef struct {
 205     createMetricFunc baseFunc;          /* base definition */
 206     resourcePredicate *predicates;      /* how to handle where refinements */
 207 } metricDefinition;
 208
 209 struct _metricRec {
 210     metricInfo info;
 211     metricDefinition definition;
 212 };
 213
 214 extern List<metricDefinitionNode*> allMIs;