Moved sample aggregation to lib/util (so paradyn could use it).
[dyninst.git] / 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;