Iinital version of paradynd speaking dynRPC igend protocol.
[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.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;