increased sliding window size for smoothed observed cost.
[dyninst.git] / paradynd / src / costmetrics.h
1 #ifndef COST_METRICS_HDR 
2 #define  COST_METRICS_HDR
3
4 #include "paradynd/src/metric.h"
5 #include "paradynd/src/process.h"
6 #include "paradynd/src/im_preds.h"
7 #include "paradynd/src/internalMetrics.h"
8 #include "paradynd/src/resource.h"
9
10 #define PAST_LIMIT 20
11
12 struct pd_past_Values{
13     float     value;
14     timeStamp len;
15 };
16 typedef pd_past_Values pd_pastValues;
17
18 class costMetric {
19   friend sampleInterval costMetricValueUpdate(costMetric *met, 
20                                               process *proc,
21                                               sampleValue value,
22                                               timeStamp endTime,
23                                               timeStamp processTime);
24  public:
25   costMetric(const string n,
26              metricStyle style, 
27              int a,   // how paradyn combines values from daemons
28              const string units,
29              im_pred_struct& preds,
30              bool developerMode,
31              daemon_MetUnitsType unitstype,
32              int combiner_op); // how daemons combine values from processes
33   ~costMetric(){}
34   void enable(metricDefinitionNode *n) { node = n; }
35   void disable() { node = NULL; }
36   bool enabled() { return(node != NULL); }
37   metricStyle style() { return style_; }
38   string name() const { return name_;}
39   const char *getName() const { return name_.string_of();}
40   int aggregate() const { return agg_; }
41   //sampleValue getValue() { return (sample.value); }
42   sampleValue getValue() { return cumulativeValue; }
43   static costMetric *newCostMetric(const string n, 
44                                metricStyle style, 
45                                int a,   // how paradyn combines values
46                                const string units,
47                                im_pred_struct& preds,
48                                bool developerMode,
49                                daemon_MetUnitsType unitstype,
50                                int combiner_op); // how daemons combine values
51   
52   T_dyninstRPC::metricInfo getInfo() {
53     T_dyninstRPC::metricInfo ret;
54     ret.name = name_; ret.style = style_;
55     ret.aggregate = agg_; ret.units = units_;
56     ret.developerMode = developermode_;
57     ret.unitstype = 0;
58     if(unitstype_ == UnNormalized) ret.unitstype = 0;
59     else if (unitstype_ == Normalized) ret.unitstype = 1; 
60     else if (unitstype_ == Sampled) ret.unitstype = 2; 
61     return ret;
62   }
63
64   bool legalToInst(vector< vector<string> >& focus);
65   bool isDeveloperMode() { return developermode_; }
66
67
68   // add new entries to components, lastProcessTime, and parts
69   bool addProcess(process *p);
70   static bool addProcessToAll(process *newproc);
71   // remove new entries to components, lastProcessTime, and parts
72   bool removeProcess(process *p);
73   static bool removeProcessFromAll(process *proc);
74
75   timeStamp getLastSampleTime(process *proc){
76       for(unsigned i=0; i < components.size(); i++){
77           if(proc == components[i]){
78                 //return(parts[i]->lastSampleEnd);
79                 return(parts[i]->lastSampleTime());
80       } }
81       return 0.0;
82   }
83   timeStamp getLastSampleProcessTime(process *proc){
84       for(unsigned i = 0; i < components.size(); i++){
85           if(proc == components[i]){
86               return(lastProcessTime[i]);
87       } }
88       return 0.0;
89   }
90   sampleValue getCumulativeValue(process *proc){
91       for(unsigned i = 0; i < components.size(); i++){
92           if(proc == components[i]){
93               return(cumulative_values[i]);
94       } }
95       return 0.0;
96   }
97
98   // updates the value of the cost metric 
99   void updateValue(process *proc,        // process sending cost data
100                    sampleValue newValue,  // new value 
101                    timeStamp endTime,    // wall time
102                    timeStamp processTime);  // CPU time
103   // updates the smoothed value of the cost metric
104   void updateSmoothValue(process *, sampleValue ,timeStamp, timeStamp ); 
105
106   static vector<costMetric*> allCostMetrics;
107   metricDefinitionNode *node;
108
109 private:
110   // list of processes and values contributing to metric value
111   vector<process *> components;
112   vector<sampleInfo *> parts;
113   aggregateSample aggSample;
114
115   vector<sampleValue> cumulative_values;
116
117   // process times associated with each component wall times are contained
118   // in the parts vector
119   vector<timeStamp> lastProcessTime;
120
121   // circular list of past values for the metric (for computing smoothed costs)
122   // these values are normalized by time
123   pd_pastValues past[PAST_LIMIT];
124   int  past_head;
125   sampleValue smooth_sample;
126   // sampleInfo sample;
127   sampleValue cumulativeValue;
128
129   string name_;
130   int agg_;
131   metricStyle style_;
132   string units_;
133   im_pred_struct pred;
134   bool developermode_;
135   daemon_MetUnitsType unitstype_;
136   int combinerop_;
137 };
138
139 #endif