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