made firstValueReceived const
[dyninst.git] / pdutil / h / aggregateSample.h
1 /*
2  * Copyright (c) 1996 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 //
43 // Define a class for a sample value.
44 //    Sample values can be a single value or may be the result of an aggregate.
45 //    This is in the util library because both paradynd's and paradyn need to
46 //      use it.
47 //
48
49 #ifndef UTIL_SAMPLE
50 #define UTIL_SAMPLE
51
52 //#include "util/h/list.h"
53 #include "util/h/hist.h"
54 #include "util/h/Vector.h"
55 #include "util/h/aggregation.h"
56
57 //
58 // What gets returned when a newValue is called in sampleInfo;
59 struct sampleInterval {
60     bool valid;
61     timeStamp   start;
62     timeStamp   end;
63     sampleValue value;
64 };
65
66 // class sampleInfo: define a class for sample values. This class should be used
67 // with class aggregatesample. sampleInfo objects are allocated and deallocated
68 // by class aggregateSample.
69 // Objects are allocated by aggregateSample::newSampleInfo.
70 // All sampleInfo object must be a component of at least one aggregateSample, 
71 // and they can of more many aggregateSamples.
72
73 class sampleInfo {
74   friend class aggregateSample;
75
76   public:
77  
78     bool firstValueReceived() const { return firstSampleReceived; }
79
80 //    void startTime(timeStamp startTime_);
81    void firstTimeAndValue(timeStamp, int firstValue);
82    void firstTimeAndValue(timeStamp, float firstValue);
83
84     void newValue(timeStamp wallTime, int value,
85                   unsigned weight_ = 1);
86
87     void newValue(timeStamp wallTime, sampleValue value, 
88                   unsigned weight_ = 1);
89
90     timeStamp lastSampleTime() { return lastSampleEnd; }
91
92     // constructor and destructor are private. 
93     // They should only be used by class aggregateSample.
94
95 private:
96
97     sampleInfo() {
98         firstSampleReceived = false;
99         lastSampleStart = 0.0;
100         lastSampleEnd = 0.0;
101         lastSample = 0.0;
102         weight = 1;
103         numAggregators = 0;
104     }
105
106     ~sampleInfo() {};
107
108     sampleInfo &operator=(const sampleInfo &src) {
109        if (&src == this)
110           return *this;
111        
112        firstSampleReceived = src.firstSampleReceived;
113        lastSampleStart = src.lastSampleStart;
114        lastSampleEnd = src.lastSampleEnd;
115        lastSample = src.lastSample;
116        weight = src.weight;
117        numAggregators = src.numAggregators;
118        return *this;
119     }
120
121     bool firstSampleReceived;        // has first sample been recorded
122     timeStamp   lastSampleStart;        // start time for last sample
123     timeStamp   lastSampleEnd;          // end time for last sample
124     sampleValue lastSample;             // what was the last sample increment
125     unsigned numAggregators;            // number of aggregateSample this is a part of
126     unsigned weight;                    // weight of this sample
127 };
128
129
130 // aggregateSample: aggregate values for samples. aggregate samples can have
131 // one or more components. Components can be added or removed at any time.
132
133 class aggregateSample {
134
135 public:
136   
137   aggregateSample(int aggregateOp) {
138     assert(aggregateOp == aggSum || aggregateOp == aggAvg || aggregateOp == aggMin
139            || aggregateOp == aggMax);
140     aggOp = aggregateOp;
141     lastSampleStart = 0.0;
142     lastSampleEnd = 0.0;
143   }
144
145   ~aggregateSample() {
146     unsigned u;
147     for (u = 0; u < newParts.size(); u++)
148       if (--newParts[u]->numAggregators == 0)
149         delete newParts[u];
150     for (u = 0; u < parts.size(); u++)
151       if (--parts[u]->numAggregators == 0)
152         delete parts[u];
153   }
154
155   sampleInfo *newComponent() {
156     sampleInfo *comp = new sampleInfo();
157     addComponent(comp);
158     return comp;
159   }
160
161   void addComponent(sampleInfo *comp) {
162     newParts += comp;
163     removedNewParts += false;
164     comp->numAggregators++;
165   }
166
167   // remove a component. The sampleInfo object will be deallocated once
168   // its value has been aggregated.
169   void removeComponent(sampleInfo *comp) {
170     for (unsigned u1 = 0; u1 < parts.size(); u1++) {
171       if (parts[u1] == comp) {
172         removedParts[u1] = true;
173         return;
174       }
175     }
176     for (unsigned u2 = 0; u2 < newParts.size(); u2++) {
177       if (newParts[u2] == comp) {
178         removedNewParts[u2] = true;
179         return;
180       }
181     }
182     assert(0);
183   }
184
185   // aggregate the values for all components.
186   struct sampleInterval aggregateValues();
187
188   // return the number of components included in the last valid aggregate value.
189   inline unsigned numComponents() {
190     return parts.size();
191   }
192
193   timeStamp currentTime() { return lastSampleEnd; }
194
195 private:
196
197   int aggOp;                        // the aggregate operator (sum, avg, min, max)
198   timeStamp lastSampleStart;        // start time of last sample
199   timeStamp lastSampleEnd;          // end time of last sample
200   vector<sampleInfo *> parts;       // the parts that are being aggregated.
201                                     // For all u, 
202                                     //    parts[u]->lastSampleStart == lastSampleEnd
203   vector<bool> removedParts;        // true if parts[u] has been removed.
204                                     // Once parts[u]->lastSampleStart ==
205                                     //                 parts[u]->lastSampleEnd
206                                     // parts[u] will be deleted.
207   vector<sampleInfo *> newParts;    // new parts that have been added to the 
208                                     // aggregation, but cannot be aggregated yet
209                                     // because their start time is not aligned with
210                                     // lastSampleEnd.
211   vector<bool> removedNewParts;     // new parts that have been removed.
212 };
213
214 #endif
215