1/*
2 * Copyright (c) 2003-2005 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * Authors: Nathan Binkert
29 */
30
31/** @file
32 * Declaration of Statistics objects.
33 */
34
35/**
36* @todo
37*
38* Generalized N-dimensinal vector
39* documentation
40* key stats
41* interval stats
42* -- these both can use the same function that prints out a
43* specific set of stats
44* VectorStandardDeviation totals
45* Document Namespaces
46*/
47#ifndef __BASE_STATISTICS_HH__
48#define __BASE_STATISTICS_HH__
49
50#include <algorithm>
51#include <cassert>
52#ifdef __SUNPRO_CC
53#include <math.h>
54#endif
55#include <cmath>
56#include <functional>
57#include <iosfwd>
58#include <list>
59#include <string>
60#include <vector>
61
62#include "base/cast.hh"
63#include "base/cprintf.hh"
64#include "base/intmath.hh"
65#include "base/refcnt.hh"
66#include "base/stats/info.hh"
67#include "base/stats/types.hh"
68#include "base/stats/visit.hh"
69#include "base/str.hh"
70#include "base/types.hh"
71
72class Callback;
73
74/** The current simulated tick. */
75extern Tick curTick;
76
77/* A namespace for all of the Statistics */
78namespace Stats {
79
80template <class Stat, class Base>
81class InfoProxy : public Base
82{
83 protected:
84 Stat &s;
85
86 public:
87 InfoProxy(Stat &stat) : s(stat) {}
88
89 bool check() const { return s.check(); }
90 void prepare() { s.prepare(); }
91 void reset() { s.reset(); }
92 void
93 visit(Visit &visitor)
94 {
95 visitor.visit(*static_cast<Base *>(this));
96 }
97 bool zero() const { return s.zero(); }
98};
99
100template <class Stat>
101class ScalarInfoProxy : public InfoProxy<Stat, ScalarInfo>
102{
103 public:
104 ScalarInfoProxy(Stat &stat) : InfoProxy<Stat, ScalarInfo>(stat) {}
105
106 Counter value() const { return this->s.value(); }
107 Result result() const { return this->s.result(); }
108 Result total() const { return this->s.total(); }
109};
110
111template <class Stat>
112class VectorInfoProxy : public InfoProxy<Stat, VectorInfo>
113{
114 protected:
115 mutable VCounter cvec;
116 mutable VResult rvec;
117
118 public:
119 VectorInfoProxy(Stat &stat) : InfoProxy<Stat, VectorInfo>(stat) {}
120
121 size_type size() const { return this->s.size(); }
122
123 VCounter &
124 value() const
125 {
126 this->s.value(cvec);
127 return cvec;
128 }
129
130 const VResult &
131 result() const
132 {
133 this->s.result(rvec);
134 return rvec;
135 }
136
137 Result total() const { return this->s.total(); }
138};
139
140template <class Stat>
141class DistInfoProxy : public InfoProxy<Stat, DistInfo>
142{
143 public:
144 DistInfoProxy(Stat &stat) : InfoProxy<Stat, DistInfo>(stat) {}
145};
146
147template <class Stat>
148class VectorDistInfoProxy : public InfoProxy<Stat, VectorDistInfo>
149{
150 public:
151 VectorDistInfoProxy(Stat &stat) : InfoProxy<Stat, VectorDistInfo>(stat) {}
152
153 size_type size() const { return this->s.size(); }
154};
155
156template <class Stat>
157class Vector2dInfoProxy : public InfoProxy<Stat, Vector2dInfo>
158{
159 public:
160 Vector2dInfoProxy(Stat &stat) : InfoProxy<Stat, Vector2dInfo>(stat) {}
161};
162
163class InfoAccess
164{
165 protected:
166 /** Set up an info class for this statistic */
167 void setInfo(Info *info);
168 /** Save Storage class parameters if any */
169 void setParams(const StorageParams *params);
170 /** Save Storage class parameters if any */
171 void setInit();
172
173 /** Grab the information class for this statistic */
174 Info *info();
175 /** Grab the information class for this statistic */
176 const Info *info() const;
177
178 public:
179 /**
180 * Reset the stat to the default state.
181 */
182 void reset() { }
183
184 /**
185 * @return true if this stat has a value and satisfies its
186 * requirement as a prereq
187 */
188 bool zero() const { return true; }
189
190 /**
191 * Check that this stat has been set up properly and is ready for
192 * use
193 * @return true for success
194 */
195 bool check() const { return true; }
196};
197
198template <class Derived, template <class> class InfoProxyType>
199class DataWrap : public InfoAccess
200{
201 public:
202 typedef InfoProxyType<Derived> Info;
203
204 protected:
205 Derived &self() { return *static_cast<Derived *>(this); }
206
207 protected:
208 Info *
209 info()
210 {
211 return safe_cast<Info *>(InfoAccess::info());
212 }
213
214 public:
215 const Info *
216 info() const
217 {
218 return safe_cast<const Info *>(InfoAccess::info());
219 }
220
221 protected:
222 /**
223 * Copy constructor, copies are not allowed.
224 */
225 DataWrap(const DataWrap &stat);
226
227 /**
228 * Can't copy stats.
229 */
230 void operator=(const DataWrap &);
231
232 public:
233 DataWrap()
234 {
235 this->setInfo(new Info(self()));
236 }
237
238 /**
239 * Set the name and marks this stat to print at the end of simulation.
240 * @param name The new name.
241 * @return A reference to this stat.
242 */
243 Derived &
244 name(const std::string &name)
245 {
246 Info *info = this->info();
247 info->setName(name);
248 info->flags.set(print);
249 return this->self();
250 }
251 const std::string &name() const { return this->info()->name; }
252
253 /**
254 * Set the description and marks this stat to print at the end of
255 * simulation.
256 * @param desc The new description.
257 * @return A reference to this stat.
258 */
259 Derived &
260 desc(const std::string &_desc)
261 {
262 this->info()->desc = _desc;
263 return this->self();
264 }
265
266 /**
267 * Set the precision and marks this stat to print at the end of simulation.
268 * @param _precision The new precision
269 * @return A reference to this stat.
270 */
271 Derived &
272 precision(int _precision)
273 {
274 this->info()->precision = _precision;
275 return this->self();
276 }
277
278 /**
279 * Set the flags and marks this stat to print at the end of simulation.
280 * @param f The new flags.
281 * @return A reference to this stat.
282 */
283 Derived &
284 flags(Flags _flags)
285 {
286 this->info()->flags.set(_flags);
287 return this->self();
288 }
289
290 /**
291 * Set the prerequisite stat and marks this stat to print at the end of
292 * simulation.
293 * @param prereq The prerequisite stat.
294 * @return A reference to this stat.
295 */
296 template <class Stat>
297 Derived &
298 prereq(const Stat &prereq)
299 {
300 this->info()->prereq = prereq.info();
301 return this->self();
302 }
303};
304
305template <class Derived, template <class> class InfoProxyType>
306class DataWrapVec : public DataWrap<Derived, InfoProxyType>
307{
308 public:
309 typedef InfoProxyType<Derived> Info;
310
311 // The following functions are specific to vectors. If you use them
312 // in a non vector context, you will get a nice compiler error!
313
314 /**
315 * Set the subfield name for the given index, and marks this stat to print
316 * at the end of simulation.
317 * @param index The subfield index.
318 * @param name The new name of the subfield.
319 * @return A reference to this stat.
320 */
321 Derived &
322 subname(off_type index, const std::string &name)
323 {
324 Derived &self = this->self();
325 Info *info = self.info();
326
327 std::vector<std::string> &subn = info->subnames;
328 if (subn.size() <= index)
329 subn.resize(index + 1);
330 subn[index] = name;
331 return self;
332 }
333
334 // The following functions are specific to 2d vectors. If you use
335 // them in a non vector context, you will get a nice compiler
336 // error because info doesn't have the right variables.
337
338 /**
339 * Set the subfield description for the given index and marks this stat to
340 * print at the end of simulation.
341 * @param index The subfield index.
342 * @param desc The new description of the subfield
343 * @return A reference to this stat.
344 */
345 Derived &
346 subdesc(off_type index, const std::string &desc)
347 {
348 Info *info = this->info();
349
350 std::vector<std::string> &subd = info->subdescs;
351 if (subd.size() <= index)
352 subd.resize(index + 1);
353 subd[index] = desc;
354
355 return this->self();
356 }
357
358 void
359 prepare()
360 {
361 Derived &self = this->self();
362 Info *info = this->info();
363
364 size_t size = self.size();
365 for (off_type i = 0; i < size; ++i)
366 self.data(i)->prepare(info);
367 }
368
369 void
370 reset()
371 {
372 Derived &self = this->self();
373 Info *info = this->info();
374
375 size_t size = self.size();
376 for (off_type i = 0; i < size; ++i)
377 self.data(i)->reset(info);
378 }
379};
380
381template <class Derived, template <class> class InfoProxyType>
382class DataWrapVec2d : public DataWrapVec<Derived, InfoProxyType>
383{
384 public:
385 typedef InfoProxyType<Derived> Info;
386
387 /**
388 * @warning This makes the assumption that if you're gonna subnames a 2d
389 * vector, you're subnaming across all y
390 */
391 Derived &
392 ysubnames(const char **names)
393 {
394 Derived &self = this->self();
395 Info *info = this->info();
396
397 info->y_subnames.resize(self.y);
398 for (off_type i = 0; i < self.y; ++i)
399 info->y_subnames[i] = names[i];
400 return self;
401 }
402
403 Derived &
404 ysubname(off_type index, const std::string subname)
405 {
406 Derived &self = this->self();
407 Info *info = this->info();
408
409 assert(index < self.y);
410 info->y_subnames.resize(self.y);
411 info->y_subnames[index] = subname.c_str();
412 return self;
413 }
414};
415
416//////////////////////////////////////////////////////////////////////
417//
418// Simple Statistics
419//
420//////////////////////////////////////////////////////////////////////
421
422/**
423 * Templatized storage and interface for a simple scalar stat.
424 */
425class StatStor
426{
427 private:
428 /** The statistic value. */
429 Counter data;
430
431 public:
432 struct Params : public StorageParams {};
433
434 public:
435 /**
436 * Builds this storage element and calls the base constructor of the
437 * datatype.
438 */
439 StatStor(Info *info)
440 : data(Counter())
441 { }
442
443 /**
444 * The the stat to the given value.
445 * @param val The new value.
446 */
447 void set(Counter val) { data = val; }
448 /**
449 * Increment the stat by the given value.
450 * @param val The new value.
451 */
452 void inc(Counter val) { data += val; }
453 /**
454 * Decrement the stat by the given value.
455 * @param val The new value.
456 */
457 void dec(Counter val) { data -= val; }
458 /**
459 * Return the value of this stat as its base type.
460 * @return The value of this stat.
461 */
462 Counter value() const { return data; }
463 /**
464 * Return the value of this stat as a result type.
465 * @return The value of this stat.
466 */
467 Result result() const { return (Result)data; }
468 /**
469 * Prepare stat data for dumping or serialization
470 */
471 void prepare(Info *info) { }
472 /**
473 * Reset stat value to default
474 */
475 void reset(Info *info) { data = Counter(); }
476
477 /**
478 * @return true if zero value
479 */
480 bool zero() const { return data == Counter(); }
481};
482
483/**
484 * Templatized storage and interface to a per-tick average stat. This keeps
485 * a current count and updates a total (count * ticks) when this count
486 * changes. This allows the quick calculation of a per tick count of the item
487 * being watched. This is good for keeping track of residencies in structures
488 * among other things.
489 */
490class AvgStor
491{
492 private:
493 /** The current count. */
494 Counter current;
| 1/*
2 * Copyright (c) 2003-2005 The Regents of The University of Michigan
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are
7 * met: redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer;
9 * redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution;
12 * neither the name of the copyright holders nor the names of its
13 * contributors may be used to endorse or promote products derived from
14 * this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * Authors: Nathan Binkert
29 */
30
31/** @file
32 * Declaration of Statistics objects.
33 */
34
35/**
36* @todo
37*
38* Generalized N-dimensinal vector
39* documentation
40* key stats
41* interval stats
42* -- these both can use the same function that prints out a
43* specific set of stats
44* VectorStandardDeviation totals
45* Document Namespaces
46*/
47#ifndef __BASE_STATISTICS_HH__
48#define __BASE_STATISTICS_HH__
49
50#include <algorithm>
51#include <cassert>
52#ifdef __SUNPRO_CC
53#include <math.h>
54#endif
55#include <cmath>
56#include <functional>
57#include <iosfwd>
58#include <list>
59#include <string>
60#include <vector>
61
62#include "base/cast.hh"
63#include "base/cprintf.hh"
64#include "base/intmath.hh"
65#include "base/refcnt.hh"
66#include "base/stats/info.hh"
67#include "base/stats/types.hh"
68#include "base/stats/visit.hh"
69#include "base/str.hh"
70#include "base/types.hh"
71
72class Callback;
73
74/** The current simulated tick. */
75extern Tick curTick;
76
77/* A namespace for all of the Statistics */
78namespace Stats {
79
80template <class Stat, class Base>
81class InfoProxy : public Base
82{
83 protected:
84 Stat &s;
85
86 public:
87 InfoProxy(Stat &stat) : s(stat) {}
88
89 bool check() const { return s.check(); }
90 void prepare() { s.prepare(); }
91 void reset() { s.reset(); }
92 void
93 visit(Visit &visitor)
94 {
95 visitor.visit(*static_cast<Base *>(this));
96 }
97 bool zero() const { return s.zero(); }
98};
99
100template <class Stat>
101class ScalarInfoProxy : public InfoProxy<Stat, ScalarInfo>
102{
103 public:
104 ScalarInfoProxy(Stat &stat) : InfoProxy<Stat, ScalarInfo>(stat) {}
105
106 Counter value() const { return this->s.value(); }
107 Result result() const { return this->s.result(); }
108 Result total() const { return this->s.total(); }
109};
110
111template <class Stat>
112class VectorInfoProxy : public InfoProxy<Stat, VectorInfo>
113{
114 protected:
115 mutable VCounter cvec;
116 mutable VResult rvec;
117
118 public:
119 VectorInfoProxy(Stat &stat) : InfoProxy<Stat, VectorInfo>(stat) {}
120
121 size_type size() const { return this->s.size(); }
122
123 VCounter &
124 value() const
125 {
126 this->s.value(cvec);
127 return cvec;
128 }
129
130 const VResult &
131 result() const
132 {
133 this->s.result(rvec);
134 return rvec;
135 }
136
137 Result total() const { return this->s.total(); }
138};
139
140template <class Stat>
141class DistInfoProxy : public InfoProxy<Stat, DistInfo>
142{
143 public:
144 DistInfoProxy(Stat &stat) : InfoProxy<Stat, DistInfo>(stat) {}
145};
146
147template <class Stat>
148class VectorDistInfoProxy : public InfoProxy<Stat, VectorDistInfo>
149{
150 public:
151 VectorDistInfoProxy(Stat &stat) : InfoProxy<Stat, VectorDistInfo>(stat) {}
152
153 size_type size() const { return this->s.size(); }
154};
155
156template <class Stat>
157class Vector2dInfoProxy : public InfoProxy<Stat, Vector2dInfo>
158{
159 public:
160 Vector2dInfoProxy(Stat &stat) : InfoProxy<Stat, Vector2dInfo>(stat) {}
161};
162
163class InfoAccess
164{
165 protected:
166 /** Set up an info class for this statistic */
167 void setInfo(Info *info);
168 /** Save Storage class parameters if any */
169 void setParams(const StorageParams *params);
170 /** Save Storage class parameters if any */
171 void setInit();
172
173 /** Grab the information class for this statistic */
174 Info *info();
175 /** Grab the information class for this statistic */
176 const Info *info() const;
177
178 public:
179 /**
180 * Reset the stat to the default state.
181 */
182 void reset() { }
183
184 /**
185 * @return true if this stat has a value and satisfies its
186 * requirement as a prereq
187 */
188 bool zero() const { return true; }
189
190 /**
191 * Check that this stat has been set up properly and is ready for
192 * use
193 * @return true for success
194 */
195 bool check() const { return true; }
196};
197
198template <class Derived, template <class> class InfoProxyType>
199class DataWrap : public InfoAccess
200{
201 public:
202 typedef InfoProxyType<Derived> Info;
203
204 protected:
205 Derived &self() { return *static_cast<Derived *>(this); }
206
207 protected:
208 Info *
209 info()
210 {
211 return safe_cast<Info *>(InfoAccess::info());
212 }
213
214 public:
215 const Info *
216 info() const
217 {
218 return safe_cast<const Info *>(InfoAccess::info());
219 }
220
221 protected:
222 /**
223 * Copy constructor, copies are not allowed.
224 */
225 DataWrap(const DataWrap &stat);
226
227 /**
228 * Can't copy stats.
229 */
230 void operator=(const DataWrap &);
231
232 public:
233 DataWrap()
234 {
235 this->setInfo(new Info(self()));
236 }
237
238 /**
239 * Set the name and marks this stat to print at the end of simulation.
240 * @param name The new name.
241 * @return A reference to this stat.
242 */
243 Derived &
244 name(const std::string &name)
245 {
246 Info *info = this->info();
247 info->setName(name);
248 info->flags.set(print);
249 return this->self();
250 }
251 const std::string &name() const { return this->info()->name; }
252
253 /**
254 * Set the description and marks this stat to print at the end of
255 * simulation.
256 * @param desc The new description.
257 * @return A reference to this stat.
258 */
259 Derived &
260 desc(const std::string &_desc)
261 {
262 this->info()->desc = _desc;
263 return this->self();
264 }
265
266 /**
267 * Set the precision and marks this stat to print at the end of simulation.
268 * @param _precision The new precision
269 * @return A reference to this stat.
270 */
271 Derived &
272 precision(int _precision)
273 {
274 this->info()->precision = _precision;
275 return this->self();
276 }
277
278 /**
279 * Set the flags and marks this stat to print at the end of simulation.
280 * @param f The new flags.
281 * @return A reference to this stat.
282 */
283 Derived &
284 flags(Flags _flags)
285 {
286 this->info()->flags.set(_flags);
287 return this->self();
288 }
289
290 /**
291 * Set the prerequisite stat and marks this stat to print at the end of
292 * simulation.
293 * @param prereq The prerequisite stat.
294 * @return A reference to this stat.
295 */
296 template <class Stat>
297 Derived &
298 prereq(const Stat &prereq)
299 {
300 this->info()->prereq = prereq.info();
301 return this->self();
302 }
303};
304
305template <class Derived, template <class> class InfoProxyType>
306class DataWrapVec : public DataWrap<Derived, InfoProxyType>
307{
308 public:
309 typedef InfoProxyType<Derived> Info;
310
311 // The following functions are specific to vectors. If you use them
312 // in a non vector context, you will get a nice compiler error!
313
314 /**
315 * Set the subfield name for the given index, and marks this stat to print
316 * at the end of simulation.
317 * @param index The subfield index.
318 * @param name The new name of the subfield.
319 * @return A reference to this stat.
320 */
321 Derived &
322 subname(off_type index, const std::string &name)
323 {
324 Derived &self = this->self();
325 Info *info = self.info();
326
327 std::vector<std::string> &subn = info->subnames;
328 if (subn.size() <= index)
329 subn.resize(index + 1);
330 subn[index] = name;
331 return self;
332 }
333
334 // The following functions are specific to 2d vectors. If you use
335 // them in a non vector context, you will get a nice compiler
336 // error because info doesn't have the right variables.
337
338 /**
339 * Set the subfield description for the given index and marks this stat to
340 * print at the end of simulation.
341 * @param index The subfield index.
342 * @param desc The new description of the subfield
343 * @return A reference to this stat.
344 */
345 Derived &
346 subdesc(off_type index, const std::string &desc)
347 {
348 Info *info = this->info();
349
350 std::vector<std::string> &subd = info->subdescs;
351 if (subd.size() <= index)
352 subd.resize(index + 1);
353 subd[index] = desc;
354
355 return this->self();
356 }
357
358 void
359 prepare()
360 {
361 Derived &self = this->self();
362 Info *info = this->info();
363
364 size_t size = self.size();
365 for (off_type i = 0; i < size; ++i)
366 self.data(i)->prepare(info);
367 }
368
369 void
370 reset()
371 {
372 Derived &self = this->self();
373 Info *info = this->info();
374
375 size_t size = self.size();
376 for (off_type i = 0; i < size; ++i)
377 self.data(i)->reset(info);
378 }
379};
380
381template <class Derived, template <class> class InfoProxyType>
382class DataWrapVec2d : public DataWrapVec<Derived, InfoProxyType>
383{
384 public:
385 typedef InfoProxyType<Derived> Info;
386
387 /**
388 * @warning This makes the assumption that if you're gonna subnames a 2d
389 * vector, you're subnaming across all y
390 */
391 Derived &
392 ysubnames(const char **names)
393 {
394 Derived &self = this->self();
395 Info *info = this->info();
396
397 info->y_subnames.resize(self.y);
398 for (off_type i = 0; i < self.y; ++i)
399 info->y_subnames[i] = names[i];
400 return self;
401 }
402
403 Derived &
404 ysubname(off_type index, const std::string subname)
405 {
406 Derived &self = this->self();
407 Info *info = this->info();
408
409 assert(index < self.y);
410 info->y_subnames.resize(self.y);
411 info->y_subnames[index] = subname.c_str();
412 return self;
413 }
414};
415
416//////////////////////////////////////////////////////////////////////
417//
418// Simple Statistics
419//
420//////////////////////////////////////////////////////////////////////
421
422/**
423 * Templatized storage and interface for a simple scalar stat.
424 */
425class StatStor
426{
427 private:
428 /** The statistic value. */
429 Counter data;
430
431 public:
432 struct Params : public StorageParams {};
433
434 public:
435 /**
436 * Builds this storage element and calls the base constructor of the
437 * datatype.
438 */
439 StatStor(Info *info)
440 : data(Counter())
441 { }
442
443 /**
444 * The the stat to the given value.
445 * @param val The new value.
446 */
447 void set(Counter val) { data = val; }
448 /**
449 * Increment the stat by the given value.
450 * @param val The new value.
451 */
452 void inc(Counter val) { data += val; }
453 /**
454 * Decrement the stat by the given value.
455 * @param val The new value.
456 */
457 void dec(Counter val) { data -= val; }
458 /**
459 * Return the value of this stat as its base type.
460 * @return The value of this stat.
461 */
462 Counter value() const { return data; }
463 /**
464 * Return the value of this stat as a result type.
465 * @return The value of this stat.
466 */
467 Result result() const { return (Result)data; }
468 /**
469 * Prepare stat data for dumping or serialization
470 */
471 void prepare(Info *info) { }
472 /**
473 * Reset stat value to default
474 */
475 void reset(Info *info) { data = Counter(); }
476
477 /**
478 * @return true if zero value
479 */
480 bool zero() const { return data == Counter(); }
481};
482
483/**
484 * Templatized storage and interface to a per-tick average stat. This keeps
485 * a current count and updates a total (count * ticks) when this count
486 * changes. This allows the quick calculation of a per tick count of the item
487 * being watched. This is good for keeping track of residencies in structures
488 * among other things.
489 */
490class AvgStor
491{
492 private:
493 /** The current count. */
494 Counter current;
|
576 }
577
578};
579
580/**
581 * Implementation of a scalar stat. The type of stat is determined by the
582 * Storage template.
583 */
584template <class Derived, class Stor>
585class ScalarBase : public DataWrap<Derived, ScalarInfoProxy>
586{
587 public:
588 typedef Stor Storage;
589 typedef typename Stor::Params Params;
590
591 protected:
592 /** The storage of this stat. */
593 char storage[sizeof(Storage)] __attribute__ ((aligned (8)));
594
595 protected:
596 /**
597 * Retrieve the storage.
598 * @param index The vector index to access.
599 * @return The storage object at the given index.
600 */
601 Storage *
602 data()
603 {
604 return reinterpret_cast<Storage *>(storage);
605 }
606
607 /**
608 * Retrieve a const pointer to the storage.
609 * for the given index.
610 * @param index The vector index to access.
611 * @return A const pointer to the storage object at the given index.
612 */
613 const Storage *
614 data() const
615 {
616 return reinterpret_cast<const Storage *>(storage);
617 }
618
619 void
620 doInit()
621 {
622 new (storage) Storage(this->info());
623 this->setInit();
624 }
625
626 public:
627 /**
628 * Return the current value of this stat as its base type.
629 * @return The current value.
630 */
631 Counter value() const { return data()->value(); }
632
633 public:
634 ScalarBase()
635 {
636 this->doInit();
637 }
638
639 public:
640 // Common operators for stats
641 /**
642 * Increment the stat by 1. This calls the associated storage object inc
643 * function.
644 */
645 void operator++() { data()->inc(1); }
646 /**
647 * Decrement the stat by 1. This calls the associated storage object dec
648 * function.
649 */
650 void operator--() { data()->dec(1); }
651
652 /** Increment the stat by 1. */
653 void operator++(int) { ++*this; }
654 /** Decrement the stat by 1. */
655 void operator--(int) { --*this; }
656
657 /**
658 * Set the data value to the given value. This calls the associated storage
659 * object set function.
660 * @param v The new value.
661 */
662 template <typename U>
663 void operator=(const U &v) { data()->set(v); }
664
665 /**
666 * Increment the stat by the given value. This calls the associated
667 * storage object inc function.
668 * @param v The value to add.
669 */
670 template <typename U>
671 void operator+=(const U &v) { data()->inc(v); }
672
673 /**
674 * Decrement the stat by the given value. This calls the associated
675 * storage object dec function.
676 * @param v The value to substract.
677 */
678 template <typename U>
679 void operator-=(const U &v) { data()->dec(v); }
680
681 /**
682 * Return the number of elements, always 1 for a scalar.
683 * @return 1.
684 */
685 size_type size() const { return 1; }
686
687 Counter value() { return data()->value(); }
688
689 Result result() { return data()->result(); }
690
691 Result total() { return result(); }
692
693 bool zero() { return result() == 0.0; }
694
695 void reset() { data()->reset(this->info()); }
696 void prepare() { data()->prepare(this->info()); }
697};
698
699class ProxyInfo : public ScalarInfo
700{
701 public:
702 std::string str() const { return to_string(value()); }
703 size_type size() const { return 1; }
704 bool check() const { return true; }
705 void prepare() { }
706 void reset() { }
707 bool zero() const { return value() == 0; }
708
709 void visit(Visit &visitor) { visitor.visit(*this); }
710};
711
712template <class T>
713class ValueProxy : public ProxyInfo
714{
715 private:
716 T *scalar;
717
718 public:
719 ValueProxy(T &val) : scalar(&val) {}
720 Counter value() const { return *scalar; }
721 Result result() const { return *scalar; }
722 Result total() const { return *scalar; }
723};
724
725template <class T>
726class FunctorProxy : public ProxyInfo
727{
728 private:
729 T *functor;
730
731 public:
732 FunctorProxy(T &func) : functor(&func) {}
733 Counter value() const { return (*functor)(); }
734 Result result() const { return (*functor)(); }
735 Result total() const { return (*functor)(); }
736};
737
738template <class Derived>
739class ValueBase : public DataWrap<Derived, ScalarInfoProxy>
740{
741 private:
742 ProxyInfo *proxy;
743
744 public:
745 ValueBase() : proxy(NULL) { }
746 ~ValueBase() { if (proxy) delete proxy; }
747
748 template <class T>
749 Derived &
750 scalar(T &value)
751 {
752 proxy = new ValueProxy<T>(value);
753 this->setInit();
754 return this->self();
755 }
756
757 template <class T>
758 Derived &
759 functor(T &func)
760 {
761 proxy = new FunctorProxy<T>(func);
762 this->setInit();
763 return this->self();
764 }
765
766 Counter value() { return proxy->value(); }
767 Result result() const { return proxy->result(); }
768 Result total() const { return proxy->total(); };
769 size_type size() const { return proxy->size(); }
770
771 std::string str() const { return proxy->str(); }
772 bool zero() const { return proxy->zero(); }
773 bool check() const { return proxy != NULL; }
774 void prepare() { }
775 void reset() { }
776};
777
778//////////////////////////////////////////////////////////////////////
779//
780// Vector Statistics
781//
782//////////////////////////////////////////////////////////////////////
783
784/**
785 * A proxy class to access the stat at a given index in a VectorBase stat.
786 * Behaves like a ScalarBase.
787 */
788template <class Stat>
789class ScalarProxy
790{
791 private:
792 /** Pointer to the parent Vector. */
793 Stat &stat;
794
795 /** The index to access in the parent VectorBase. */
796 off_type index;
797
798 public:
799 /**
800 * Return the current value of this stat as its base type.
801 * @return The current value.
802 */
803 Counter value() const { return stat.data(index)->value(); }
804
805 /**
806 * Return the current value of this statas a result type.
807 * @return The current value.
808 */
809 Result result() const { return stat.data(index)->result(); }
810
811 public:
812 /**
813 * Create and initialize this proxy, do not register it with the database.
814 * @param i The index to access.
815 */
816 ScalarProxy(Stat &s, off_type i)
817 : stat(s), index(i)
818 {
819 }
820
821 /**
822 * Create a copy of the provided ScalarProxy.
823 * @param sp The proxy to copy.
824 */
825 ScalarProxy(const ScalarProxy &sp)
826 : stat(sp.stat), index(sp.index)
827 {}
828
829 /**
830 * Set this proxy equal to the provided one.
831 * @param sp The proxy to copy.
832 * @return A reference to this proxy.
833 */
834 const ScalarProxy &
835 operator=(const ScalarProxy &sp)
836 {
837 stat = sp.stat;
838 index = sp.index;
839 return *this;
840 }
841
842 public:
843 // Common operators for stats
844 /**
845 * Increment the stat by 1. This calls the associated storage object inc
846 * function.
847 */
848 void operator++() { stat.data(index)->inc(1); }
849 /**
850 * Decrement the stat by 1. This calls the associated storage object dec
851 * function.
852 */
853 void operator--() { stat.data(index)->dec(1); }
854
855 /** Increment the stat by 1. */
856 void operator++(int) { ++*this; }
857 /** Decrement the stat by 1. */
858 void operator--(int) { --*this; }
859
860 /**
861 * Set the data value to the given value. This calls the associated storage
862 * object set function.
863 * @param v The new value.
864 */
865 template <typename U>
866 void
867 operator=(const U &v)
868 {
869 stat.data(index)->set(v);
870 }
871
872 /**
873 * Increment the stat by the given value. This calls the associated
874 * storage object inc function.
875 * @param v The value to add.
876 */
877 template <typename U>
878 void
879 operator+=(const U &v)
880 {
881 stat.data(index)->inc(v);
882 }
883
884 /**
885 * Decrement the stat by the given value. This calls the associated
886 * storage object dec function.
887 * @param v The value to substract.
888 */
889 template <typename U>
890 void
891 operator-=(const U &v)
892 {
893 stat.data(index)->dec(v);
894 }
895
896 /**
897 * Return the number of elements, always 1 for a scalar.
898 * @return 1.
899 */
900 size_type size() const { return 1; }
901
902 public:
903 std::string
904 str() const
905 {
906 return csprintf("%s[%d]", stat.info()->name, index);
907 }
908};
909
910/**
911 * Implementation of a vector of stats. The type of stat is determined by the
912 * Storage class. @sa ScalarBase
913 */
914template <class Derived, class Stor>
915class VectorBase : public DataWrapVec<Derived, VectorInfoProxy>
916{
917 public:
918 typedef Stor Storage;
919 typedef typename Stor::Params Params;
920
921 /** Proxy type */
922 typedef ScalarProxy<Derived> Proxy;
923 friend class ScalarProxy<Derived>;
924 friend class DataWrapVec<Derived, VectorInfoProxy>;
925
926 protected:
927 /** The storage of this stat. */
928 Storage *storage;
929 size_type _size;
930
931 protected:
932 /**
933 * Retrieve the storage.
934 * @param index The vector index to access.
935 * @return The storage object at the given index.
936 */
937 Storage *data(off_type index) { return &storage[index]; }
938
939 /**
940 * Retrieve a const pointer to the storage.
941 * @param index The vector index to access.
942 * @return A const pointer to the storage object at the given index.
943 */
944 const Storage *data(off_type index) const { return &storage[index]; }
945
946 void
947 doInit(size_type s)
948 {
949 assert(s > 0 && "size must be positive!");
950 assert(!storage && "already initialized");
951 _size = s;
952
953 char *ptr = new char[_size * sizeof(Storage)];
954 storage = reinterpret_cast<Storage *>(ptr);
955
956 for (off_type i = 0; i < _size; ++i)
957 new (&storage[i]) Storage(this->info());
958
959 this->setInit();
960 }
961
962 public:
963 void
964 value(VCounter &vec) const
965 {
966 vec.resize(size());
967 for (off_type i = 0; i < size(); ++i)
968 vec[i] = data(i)->value();
969 }
970
971 /**
972 * Copy the values to a local vector and return a reference to it.
973 * @return A reference to a vector of the stat values.
974 */
975 void
976 result(VResult &vec) const
977 {
978 vec.resize(size());
979 for (off_type i = 0; i < size(); ++i)
980 vec[i] = data(i)->result();
981 }
982
983 /**
984 * Return a total of all entries in this vector.
985 * @return The total of all vector entries.
986 */
987 Result
988 total() const
989 {
990 Result total = 0.0;
991 for (off_type i = 0; i < size(); ++i)
992 total += data(i)->result();
993 return total;
994 }
995
996 /**
997 * @return the number of elements in this vector.
998 */
999 size_type size() const { return _size; }
1000
1001 bool
1002 zero() const
1003 {
1004 for (off_type i = 0; i < size(); ++i)
1005 if (data(i)->zero())
1006 return false;
1007 return true;
1008 }
1009
1010 bool
1011 check() const
1012 {
1013 return storage != NULL;
1014 }
1015
1016 public:
1017 VectorBase()
1018 : storage(NULL)
1019 {}
1020
1021 ~VectorBase()
1022 {
1023 if (!storage)
1024 return;
1025
1026 for (off_type i = 0; i < _size; ++i)
1027 data(i)->~Storage();
1028 delete [] reinterpret_cast<char *>(storage);
1029 }
1030
1031 /**
1032 * Set this vector to have the given size.
1033 * @param size The new size.
1034 * @return A reference to this stat.
1035 */
1036 Derived &
1037 init(size_type size)
1038 {
1039 Derived &self = this->self();
1040 self.doInit(size);
1041 return self;
1042 }
1043
1044 /**
1045 * Return a reference (ScalarProxy) to the stat at the given index.
1046 * @param index The vector index to access.
1047 * @return A reference of the stat.
1048 */
1049 Proxy
1050 operator[](off_type index)
1051 {
1052 assert (index >= 0 && index < size());
1053 return Proxy(this->self(), index);
1054 }
1055};
1056
1057template <class Stat>
1058class VectorProxy
1059{
1060 private:
1061 Stat &stat;
1062 off_type offset;
1063 size_type len;
1064
1065 private:
1066 mutable VResult vec;
1067
1068 typename Stat::Storage *
1069 data(off_type index)
1070 {
1071 assert(index < len);
1072 return stat.data(offset + index);
1073 }
1074
1075 const typename Stat::Storage *
1076 data(off_type index) const
1077 {
1078 assert(index < len);
1079 return stat.data(offset + index);
1080 }
1081
1082 public:
1083 const VResult &
1084 result() const
1085 {
1086 vec.resize(size());
1087
1088 for (off_type i = 0; i < size(); ++i)
1089 vec[i] = data(i)->result();
1090
1091 return vec;
1092 }
1093
1094 Result
1095 total() const
1096 {
1097 Result total = 0.0;
1098 for (off_type i = 0; i < size(); ++i)
1099 total += data(i)->result();
1100 return total;
1101 }
1102
1103 public:
1104 VectorProxy(Stat &s, off_type o, size_type l)
1105 : stat(s), offset(o), len(l)
1106 {
1107 }
1108
1109 VectorProxy(const VectorProxy &sp)
1110 : stat(sp.stat), offset(sp.offset), len(sp.len)
1111 {
1112 }
1113
1114 const VectorProxy &
1115 operator=(const VectorProxy &sp)
1116 {
1117 stat = sp.stat;
1118 offset = sp.offset;
1119 len = sp.len;
1120 return *this;
1121 }
1122
1123 ScalarProxy<Stat>
1124 operator[](off_type index)
1125 {
1126 assert (index >= 0 && index < size());
1127 return ScalarProxy<Stat>(stat, offset + index);
1128 }
1129
1130 size_type size() const { return len; }
1131};
1132
1133template <class Derived, class Stor>
1134class Vector2dBase : public DataWrapVec2d<Derived, Vector2dInfoProxy>
1135{
1136 public:
1137 typedef Vector2dInfoProxy<Derived> Info;
1138 typedef Stor Storage;
1139 typedef typename Stor::Params Params;
1140 typedef VectorProxy<Derived> Proxy;
1141 friend class ScalarProxy<Derived>;
1142 friend class VectorProxy<Derived>;
1143 friend class DataWrapVec<Derived, Vector2dInfoProxy>;
1144 friend class DataWrapVec2d<Derived, Vector2dInfoProxy>;
1145
1146 protected:
1147 size_type x;
1148 size_type y;
1149 size_type _size;
1150 Storage *storage;
1151
1152 protected:
1153 Storage *data(off_type index) { return &storage[index]; }
1154 const Storage *data(off_type index) const { return &storage[index]; }
1155
1156 public:
1157 Vector2dBase()
1158 : storage(NULL)
1159 {}
1160
1161 ~Vector2dBase()
1162 {
1163 if (!storage)
1164 return;
1165
1166 for (off_type i = 0; i < _size; ++i)
1167 data(i)->~Storage();
1168 delete [] reinterpret_cast<char *>(storage);
1169 }
1170
1171 Derived &
1172 init(size_type _x, size_type _y)
1173 {
1174 assert(_x > 0 && _y > 0 && "sizes must be positive!");
1175 assert(!storage && "already initialized");
1176
1177 Derived &self = this->self();
1178 Info *info = this->info();
1179
1180 x = _x;
1181 y = _y;
1182 info->x = _x;
1183 info->y = _y;
1184 _size = x * y;
1185
1186 char *ptr = new char[_size * sizeof(Storage)];
1187 storage = reinterpret_cast<Storage *>(ptr);
1188
1189 for (off_type i = 0; i < _size; ++i)
1190 new (&storage[i]) Storage(info);
1191
1192 this->setInit();
1193
1194 return self;
1195 }
1196
1197 std::string ysubname(off_type i) const { return (*this->y_subnames)[i]; }
1198
1199 Proxy
1200 operator[](off_type index)
1201 {
1202 off_type offset = index * y;
1203 assert (index >= 0 && offset + index < size());
1204 return Proxy(this->self(), offset, y);
1205 }
1206
1207
1208 size_type
1209 size() const
1210 {
1211 return _size;
1212 }
1213
1214 bool
1215 zero() const
1216 {
1217 return data(0)->zero();
1218#if 0
1219 for (off_type i = 0; i < size(); ++i)
1220 if (!data(i)->zero())
1221 return false;
1222 return true;
1223#endif
1224 }
1225
1226 void
1227 prepare()
1228 {
1229 Info *info = this->info();
1230 size_type size = this->size();
1231
1232 for (off_type i = 0; i < size; ++i)
1233 data(i)->prepare(info);
1234
1235 info->cvec.resize(size);
1236 for (off_type i = 0; i < size; ++i)
1237 info->cvec[i] = data(i)->value();
1238 }
1239
1240 /**
1241 * Reset stat value to default
1242 */
1243 void
1244 reset()
1245 {
1246 Info *info = this->info();
1247 size_type size = this->size();
1248 for (off_type i = 0; i < size; ++i)
1249 data(i)->reset(info);
1250 }
1251
1252 bool
1253 check() const
1254 {
1255 return storage != NULL;
1256 }
1257};
1258
1259//////////////////////////////////////////////////////////////////////
1260//
1261// Non formula statistics
1262//
1263//////////////////////////////////////////////////////////////////////
1264
1265/**
1266 * Templatized storage and interface for a distrbution stat.
1267 */
1268class DistStor
1269{
1270 public:
1271 /** The parameters for a distribution stat. */
1272 struct Params : public DistParams
1273 {
1274 Params() : DistParams(Dist) {}
1275 };
1276
1277 private:
1278 /** The minimum value to track. */
1279 Counter min_track;
1280 /** The maximum value to track. */
1281 Counter max_track;
1282 /** The number of entries in each bucket. */
1283 Counter bucket_size;
1284 /** The number of buckets. Equal to (max-min)/bucket_size. */
1285 size_type buckets;
1286
1287 /** The smallest value sampled. */
1288 Counter min_val;
1289 /** The largest value sampled. */
1290 Counter max_val;
1291 /** The number of values sampled less than min. */
1292 Counter underflow;
1293 /** The number of values sampled more than max. */
1294 Counter overflow;
1295 /** The current sum. */
1296 Counter sum;
1297 /** The sum of squares. */
1298 Counter squares;
1299 /** The number of samples. */
1300 Counter samples;
1301 /** Counter for each bucket. */
1302 VCounter cvec;
1303
1304 public:
1305 DistStor(Info *info)
1306 : cvec(safe_cast<const Params *>(info->storageParams)->buckets)
1307 {
1308 reset(info);
1309 }
1310
1311 /**
1312 * Add a value to the distribution for the given number of times.
1313 * @param val The value to add.
1314 * @param number The number of times to add the value.
1315 */
1316 void
1317 sample(Counter val, int number)
1318 {
1319 if (val < min_track)
1320 underflow += number;
1321 else if (val > max_track)
1322 overflow += number;
1323 else {
1324 size_type index =
1325 (size_type)std::floor((val - min_track) / bucket_size);
1326 assert(index < size());
1327 cvec[index] += number;
1328 }
1329
1330 if (val < min_val)
1331 min_val = val;
1332
1333 if (val > max_val)
1334 max_val = val;
1335
1336 Counter sample = val * number;
1337 sum += sample;
1338 squares += sample * sample;
1339 samples += number;
1340 }
1341
1342 /**
1343 * Return the number of buckets in this distribution.
1344 * @return the number of buckets.
1345 */
1346 size_type size() const { return cvec.size(); }
1347
1348 /**
1349 * Returns true if any calls to sample have been made.
1350 * @return True if any values have been sampled.
1351 */
1352 bool
1353 zero() const
1354 {
1355 return samples == Counter();
1356 }
1357
1358 void
1359 prepare(Info *info, DistData &data)
1360 {
1361 const Params *params = safe_cast<const Params *>(info->storageParams);
1362
1363 data.min_val = (min_val == CounterLimits::max()) ? 0 : min_val;
1364 data.max_val = (max_val == CounterLimits::min()) ? 0 : max_val;
1365 data.underflow = underflow;
1366 data.overflow = overflow;
1367
1368 size_type buckets = params->buckets;
1369 data.cvec.resize(buckets);
1370 for (off_type i = 0; i < buckets; ++i)
1371 data.cvec[i] = cvec[i];
1372
1373 data.sum = sum;
1374 data.squares = squares;
1375 data.samples = samples;
1376 }
1377
1378 /**
1379 * Reset stat value to default
1380 */
1381 void
1382 reset(Info *info)
1383 {
1384 const Params *params = safe_cast<const Params *>(info->storageParams);
1385 min_track = params->min;
1386 max_track = params->max;
1387 bucket_size = params->bucket_size;
1388
1389 min_val = CounterLimits::max();
1390 max_val = CounterLimits::min();
1391 underflow = Counter();
1392 overflow = Counter();
1393
1394 size_type size = cvec.size();
1395 for (off_type i = 0; i < size; ++i)
1396 cvec[i] = Counter();
1397
1398 sum = Counter();
1399 squares = Counter();
1400 samples = Counter();
1401 }
1402};
1403
1404/**
1405 * Templatized storage and interface for a distribution that calculates mean
1406 * and variance.
1407 */
1408class SampleStor
1409{
1410 public:
1411 struct Params : public DistParams
1412 {
1413 Params() : DistParams(Deviation) {}
1414 };
1415
1416 private:
1417 /** The current sum. */
1418 Counter sum;
1419 /** The sum of squares. */
1420 Counter squares;
1421 /** The number of samples. */
1422 Counter samples;
1423
1424 public:
1425 /**
1426 * Create and initialize this storage.
1427 */
1428 SampleStor(Info *info)
1429 : sum(Counter()), squares(Counter()), samples(Counter())
1430 { }
1431
1432 /**
1433 * Add a value the given number of times to this running average.
1434 * Update the running sum and sum of squares, increment the number of
1435 * values seen by the given number.
1436 * @param val The value to add.
1437 * @param number The number of times to add the value.
1438 */
1439 void
1440 sample(Counter val, int number)
1441 {
1442 Counter value = val * number;
1443 sum += value;
1444 squares += value * value;
1445 samples += number;
1446 }
1447
1448 /**
1449 * Return the number of entries in this stat, 1
1450 * @return 1.
1451 */
1452 size_type size() const { return 1; }
1453
1454 /**
1455 * Return true if no samples have been added.
1456 * @return True if no samples have been added.
1457 */
1458 bool zero() const { return samples == Counter(); }
1459
1460 void
1461 prepare(Info *info, DistData &data)
1462 {
1463 data.sum = sum;
1464 data.squares = squares;
1465 data.samples = samples;
1466 }
1467
1468 /**
1469 * Reset stat value to default
1470 */
1471 void
1472 reset(Info *info)
1473 {
1474 sum = Counter();
1475 squares = Counter();
1476 samples = Counter();
1477 }
1478};
1479
1480/**
1481 * Templatized storage for distribution that calculates per tick mean and
1482 * variance.
1483 */
1484class AvgSampleStor
1485{
1486 public:
1487 struct Params : public DistParams
1488 {
1489 Params() : DistParams(Deviation) {}
1490 };
1491
1492 private:
1493 /** Current total. */
1494 Counter sum;
1495 /** Current sum of squares. */
1496 Counter squares;
1497
1498 public:
1499 /**
1500 * Create and initialize this storage.
1501 */
1502 AvgSampleStor(Info *info)
1503 : sum(Counter()), squares(Counter())
1504 {}
1505
1506 /**
1507 * Add a value to the distribution for the given number of times.
1508 * Update the running sum and sum of squares.
1509 * @param val The value to add.
1510 * @param number The number of times to add the value.
1511 */
1512 void
1513 sample(Counter val, int number)
1514 {
1515 Counter value = val * number;
1516 sum += value;
1517 squares += value * value;
1518 }
1519
1520 /**
1521 * Return the number of entries, in this case 1.
1522 * @return 1.
1523 */
1524 size_type size() const { return 1; }
1525
1526 /**
1527 * Return true if no samples have been added.
1528 * @return True if the sum is zero.
1529 */
1530 bool zero() const { return sum == Counter(); }
1531
1532 void
1533 prepare(Info *info, DistData &data)
1534 {
1535 data.sum = sum;
1536 data.squares = squares;
1537 data.samples = curTick;
1538 }
1539
1540 /**
1541 * Reset stat value to default
1542 */
1543 void
1544 reset(Info *info)
1545 {
1546 sum = Counter();
1547 squares = Counter();
1548 }
1549};
1550
1551/**
1552 * Implementation of a distribution stat. The type of distribution is
1553 * determined by the Storage template. @sa ScalarBase
1554 */
1555template <class Derived, class Stor>
1556class DistBase : public DataWrap<Derived, DistInfoProxy>
1557{
1558 public:
1559 typedef DistInfoProxy<Derived> Info;
1560 typedef Stor Storage;
1561 typedef typename Stor::Params Params;
1562
1563 protected:
1564 /** The storage for this stat. */
1565 char storage[sizeof(Storage)] __attribute__ ((aligned (8)));
1566
1567 protected:
1568 /**
1569 * Retrieve the storage.
1570 * @return The storage object for this stat.
1571 */
1572 Storage *
1573 data()
1574 {
1575 return reinterpret_cast<Storage *>(storage);
1576 }
1577
1578 /**
1579 * Retrieve a const pointer to the storage.
1580 * @return A const pointer to the storage object for this stat.
1581 */
1582 const Storage *
1583 data() const
1584 {
1585 return reinterpret_cast<const Storage *>(storage);
1586 }
1587
1588 void
1589 doInit()
1590 {
1591 new (storage) Storage(this->info());
1592 this->setInit();
1593 }
1594
1595 public:
1596 DistBase() { }
1597
1598 /**
1599 * Add a value to the distribtion n times. Calls sample on the storage
1600 * class.
1601 * @param v The value to add.
1602 * @param n The number of times to add it, defaults to 1.
1603 */
1604 template <typename U>
1605 void sample(const U &v, int n = 1) { data()->sample(v, n); }
1606
1607 /**
1608 * Return the number of entries in this stat.
1609 * @return The number of entries.
1610 */
1611 size_type size() const { return data()->size(); }
1612 /**
1613 * Return true if no samples have been added.
1614 * @return True if there haven't been any samples.
1615 */
1616 bool zero() const { return data()->zero(); }
1617
1618 void
1619 prepare()
1620 {
1621 Info *info = this->info();
1622 data()->prepare(info, info->data);
1623 }
1624
1625 /**
1626 * Reset stat value to default
1627 */
1628 void
1629 reset()
1630 {
1631 data()->reset(this->info());
1632 }
1633};
1634
1635template <class Stat>
1636class DistProxy;
1637
1638template <class Derived, class Stor>
1639class VectorDistBase : public DataWrapVec<Derived, VectorDistInfoProxy>
1640{
1641 public:
1642 typedef VectorDistInfoProxy<Derived> Info;
1643 typedef Stor Storage;
1644 typedef typename Stor::Params Params;
1645 typedef DistProxy<Derived> Proxy;
1646 friend class DistProxy<Derived>;
1647 friend class DataWrapVec<Derived, VectorDistInfoProxy>;
1648
1649 protected:
1650 Storage *storage;
1651 size_type _size;
1652
1653 protected:
1654 Storage *
1655 data(off_type index)
1656 {
1657 return &storage[index];
1658 }
1659
1660 const Storage *
1661 data(off_type index) const
1662 {
1663 return &storage[index];
1664 }
1665
1666 void
1667 doInit(size_type s)
1668 {
1669 assert(s > 0 && "size must be positive!");
1670 assert(!storage && "already initialized");
1671 _size = s;
1672
1673 char *ptr = new char[_size * sizeof(Storage)];
1674 storage = reinterpret_cast<Storage *>(ptr);
1675
1676 Info *info = this->info();
1677 for (off_type i = 0; i < _size; ++i)
1678 new (&storage[i]) Storage(info);
1679
1680 this->setInit();
1681 }
1682
1683 public:
1684 VectorDistBase()
1685 : storage(NULL)
1686 {}
1687
1688 ~VectorDistBase()
1689 {
1690 if (!storage)
1691 return ;
1692
1693 for (off_type i = 0; i < _size; ++i)
1694 data(i)->~Storage();
1695 delete [] reinterpret_cast<char *>(storage);
1696 }
1697
1698 Proxy operator[](off_type index);
1699
1700 size_type
1701 size() const
1702 {
1703 return _size;
1704 }
1705
1706 bool
1707 zero() const
1708 {
1709 return false;
1710#if 0
1711 for (off_type i = 0; i < size(); ++i)
1712 if (!data(i)->zero())
1713 return false;
1714 return true;
1715#endif
1716 }
1717
1718 void
1719 prepare()
1720 {
1721 Info *info = this->info();
1722 size_type size = this->size();
1723 info->data.resize(size);
1724 for (off_type i = 0; i < size; ++i)
1725 data(i)->prepare(info, info->data[i]);
1726 }
1727
1728 bool
1729 check() const
1730 {
1731 return storage != NULL;
1732 }
1733};
1734
1735template <class Stat>
1736class DistProxy
1737{
1738 private:
1739 Stat *stat;
1740 off_type index;
1741
1742 protected:
1743 typename Stat::Storage *data() { return stat->data(index); }
1744 const typename Stat::Storage *data() const { return stat->data(index); }
1745
1746 public:
1747 DistProxy(Stat *s, off_type i)
1748 : stat(s), index(i)
1749 {}
1750
1751 DistProxy(const DistProxy &sp)
1752 : stat(sp.stat), index(sp.index)
1753 {}
1754
1755 const DistProxy &
1756 operator=(const DistProxy &sp)
1757 {
1758 stat = sp.stat;
1759 index = sp.index;
1760 return *this;
1761 }
1762
1763 public:
1764 template <typename U>
1765 void
1766 sample(const U &v, int n = 1)
1767 {
1768 data()->sample(v, n);
1769 }
1770
1771 size_type
1772 size() const
1773 {
1774 return 1;
1775 }
1776
1777 bool
1778 zero() const
1779 {
1780 return data()->zero();
1781 }
1782
1783 /**
1784 * Proxy has no state. Nothing to reset.
1785 */
1786 void reset() { }
1787};
1788
1789template <class Derived, class Stor>
1790inline typename VectorDistBase<Derived, Stor>::Proxy
1791VectorDistBase<Derived, Stor>::operator[](off_type index)
1792{
1793 assert (index >= 0 && index < size());
1794 typedef typename VectorDistBase<Derived, Stor>::Proxy Proxy;
1795 return Proxy(this, index);
1796}
1797
1798#if 0
1799template <class Storage>
1800Result
1801VectorDistBase<Storage>::total(off_type index) const
1802{
1803 Result total = 0.0;
1804 for (off_type i = 0; i < x_size(); ++i)
1805 total += data(i)->result();
1806}
1807#endif
1808
1809//////////////////////////////////////////////////////////////////////
1810//
1811// Formula Details
1812//
1813//////////////////////////////////////////////////////////////////////
1814
1815/**
1816 * Base class for formula statistic node. These nodes are used to build a tree
1817 * that represents the formula.
1818 */
1819class Node : public RefCounted
1820{
1821 public:
1822 /**
1823 * Return the number of nodes in the subtree starting at this node.
1824 * @return the number of nodes in this subtree.
1825 */
1826 virtual size_type size() const = 0;
1827 /**
1828 * Return the result vector of this subtree.
1829 * @return The result vector of this subtree.
1830 */
1831 virtual const VResult &result() const = 0;
1832 /**
1833 * Return the total of the result vector.
1834 * @return The total of the result vector.
1835 */
1836 virtual Result total() const = 0;
1837
1838 /**
1839 *
1840 */
1841 virtual std::string str() const = 0;
1842};
1843
1844/** Reference counting pointer to a function Node. */
1845typedef RefCountingPtr<Node> NodePtr;
1846
1847class ScalarStatNode : public Node
1848{
1849 private:
1850 const ScalarInfo *data;
1851 mutable VResult vresult;
1852
1853 public:
1854 ScalarStatNode(const ScalarInfo *d) : data(d), vresult(1) {}
1855
1856 const VResult &
1857 result() const
1858 {
1859 vresult[0] = data->result();
1860 return vresult;
1861 }
1862
1863 Result total() const { return data->result(); };
1864
1865 size_type size() const { return 1; }
1866
1867 /**
1868 *
1869 */
1870 std::string str() const { return data->name; }
1871};
1872
1873template <class Stat>
1874class ScalarProxyNode : public Node
1875{
1876 private:
1877 const ScalarProxy<Stat> proxy;
1878 mutable VResult vresult;
1879
1880 public:
1881 ScalarProxyNode(const ScalarProxy<Stat> &p)
1882 : proxy(p), vresult(1)
1883 { }
1884
1885 const VResult &
1886 result() const
1887 {
1888 vresult[0] = proxy.result();
1889 return vresult;
1890 }
1891
1892 Result
1893 total() const
1894 {
1895 return proxy.result();
1896 }
1897
1898 size_type
1899 size() const
1900 {
1901 return 1;
1902 }
1903
1904 /**
1905 *
1906 */
1907 std::string
1908 str() const
1909 {
1910 return proxy.str();
1911 }
1912};
1913
1914class VectorStatNode : public Node
1915{
1916 private:
1917 const VectorInfo *data;
1918
1919 public:
1920 VectorStatNode(const VectorInfo *d) : data(d) { }
1921 const VResult &result() const { return data->result(); }
1922 Result total() const { return data->total(); };
1923
1924 size_type size() const { return data->size(); }
1925
1926 std::string str() const { return data->name; }
1927};
1928
1929template <class T>
1930class ConstNode : public Node
1931{
1932 private:
1933 VResult vresult;
1934
1935 public:
1936 ConstNode(T s) : vresult(1, (Result)s) {}
1937 const VResult &result() const { return vresult; }
1938 Result total() const { return vresult[0]; };
1939 size_type size() const { return 1; }
1940 std::string str() const { return to_string(vresult[0]); }
1941};
1942
1943template <class T>
1944class ConstVectorNode : public Node
1945{
1946 private:
1947 VResult vresult;
1948
1949 public:
1950 ConstVectorNode(const T &s) : vresult(s.begin(), s.end()) {}
1951 const VResult &result() const { return vresult; }
1952
1953 Result
1954 total() const
1955 {
1956 size_type size = this->size();
1957 Result tmp = 0;
1958 for (off_type i = 0; i < size; i++)
1959 tmp += vresult[i];
1960 return tmp;
1961 }
1962
1963 size_type size() const { return vresult.size(); }
1964 std::string
1965 str() const
1966 {
1967 size_type size = this->size();
1968 std::string tmp = "(";
1969 for (off_type i = 0; i < size; i++)
1970 tmp += csprintf("%s ",to_string(vresult[i]));
1971 tmp += ")";
1972 return tmp;
1973 }
1974};
1975
1976template <class Op>
1977struct OpString;
1978
1979template<>
1980struct OpString<std::plus<Result> >
1981{
1982 static std::string str() { return "+"; }
1983};
1984
1985template<>
1986struct OpString<std::minus<Result> >
1987{
1988 static std::string str() { return "-"; }
1989};
1990
1991template<>
1992struct OpString<std::multiplies<Result> >
1993{
1994 static std::string str() { return "*"; }
1995};
1996
1997template<>
1998struct OpString<std::divides<Result> >
1999{
2000 static std::string str() { return "/"; }
2001};
2002
2003template<>
2004struct OpString<std::modulus<Result> >
2005{
2006 static std::string str() { return "%"; }
2007};
2008
2009template<>
2010struct OpString<std::negate<Result> >
2011{
2012 static std::string str() { return "-"; }
2013};
2014
2015template <class Op>
2016class UnaryNode : public Node
2017{
2018 public:
2019 NodePtr l;
2020 mutable VResult vresult;
2021
2022 public:
2023 UnaryNode(NodePtr &p) : l(p) {}
2024
2025 const VResult &
2026 result() const
2027 {
2028 const VResult &lvec = l->result();
2029 size_type size = lvec.size();
2030
2031 assert(size > 0);
2032
2033 vresult.resize(size);
2034 Op op;
2035 for (off_type i = 0; i < size; ++i)
2036 vresult[i] = op(lvec[i]);
2037
2038 return vresult;
2039 }
2040
2041 Result
2042 total() const
2043 {
2044 const VResult &vec = this->result();
2045 Result total = 0.0;
2046 for (off_type i = 0; i < size(); i++)
2047 total += vec[i];
2048 return total;
2049 }
2050
2051 size_type size() const { return l->size(); }
2052
2053 std::string
2054 str() const
2055 {
2056 return OpString<Op>::str() + l->str();
2057 }
2058};
2059
2060template <class Op>
2061class BinaryNode : public Node
2062{
2063 public:
2064 NodePtr l;
2065 NodePtr r;
2066 mutable VResult vresult;
2067
2068 public:
2069 BinaryNode(NodePtr &a, NodePtr &b) : l(a), r(b) {}
2070
2071 const VResult &
2072 result() const
2073 {
2074 Op op;
2075 const VResult &lvec = l->result();
2076 const VResult &rvec = r->result();
2077
2078 assert(lvec.size() > 0 && rvec.size() > 0);
2079
2080 if (lvec.size() == 1 && rvec.size() == 1) {
2081 vresult.resize(1);
2082 vresult[0] = op(lvec[0], rvec[0]);
2083 } else if (lvec.size() == 1) {
2084 size_type size = rvec.size();
2085 vresult.resize(size);
2086 for (off_type i = 0; i < size; ++i)
2087 vresult[i] = op(lvec[0], rvec[i]);
2088 } else if (rvec.size() == 1) {
2089 size_type size = lvec.size();
2090 vresult.resize(size);
2091 for (off_type i = 0; i < size; ++i)
2092 vresult[i] = op(lvec[i], rvec[0]);
2093 } else if (rvec.size() == lvec.size()) {
2094 size_type size = rvec.size();
2095 vresult.resize(size);
2096 for (off_type i = 0; i < size; ++i)
2097 vresult[i] = op(lvec[i], rvec[i]);
2098 }
2099
2100 return vresult;
2101 }
2102
2103 Result
2104 total() const
2105 {
2106 const VResult &vec = this->result();
2107 Result total = 0.0;
2108 for (off_type i = 0; i < size(); i++)
2109 total += vec[i];
2110 return total;
2111 }
2112
2113 size_type
2114 size() const
2115 {
2116 size_type ls = l->size();
2117 size_type rs = r->size();
2118 if (ls == 1) {
2119 return rs;
2120 } else if (rs == 1) {
2121 return ls;
2122 } else {
2123 assert(ls == rs && "Node vector sizes are not equal");
2124 return ls;
2125 }
2126 }
2127
2128 std::string
2129 str() const
2130 {
2131 return csprintf("(%s %s %s)", l->str(), OpString<Op>::str(), r->str());
2132 }
2133};
2134
2135template <class Op>
2136class SumNode : public Node
2137{
2138 public:
2139 NodePtr l;
2140 mutable VResult vresult;
2141
2142 public:
2143 SumNode(NodePtr &p) : l(p), vresult(1) {}
2144
2145 const VResult &
2146 result() const
2147 {
2148 const VResult &lvec = l->result();
2149 size_type size = lvec.size();
2150 assert(size > 0);
2151
2152 vresult[0] = 0.0;
2153
2154 Op op;
2155 for (off_type i = 0; i < size; ++i)
2156 vresult[0] = op(vresult[0], lvec[i]);
2157
2158 return vresult;
2159 }
2160
2161 Result
2162 total() const
2163 {
2164 const VResult &lvec = l->result();
2165 size_type size = lvec.size();
2166 assert(size > 0);
2167
2168 Result vresult = 0.0;
2169
2170 Op op;
2171 for (off_type i = 0; i < size; ++i)
2172 vresult = op(vresult, lvec[i]);
2173
2174 return vresult;
2175 }
2176
2177 size_type size() const { return 1; }
2178
2179 std::string
2180 str() const
2181 {
2182 return csprintf("total(%s)", l->str());
2183 }
2184};
2185
2186
2187//////////////////////////////////////////////////////////////////////
2188//
2189// Visible Statistics Types
2190//
2191//////////////////////////////////////////////////////////////////////
2192/**
2193 * @defgroup VisibleStats "Statistic Types"
2194 * These are the statistics that are used in the simulator.
2195 * @{
2196 */
2197
2198/**
2199 * This is a simple scalar statistic, like a counter.
2200 * @sa Stat, ScalarBase, StatStor
2201 */
2202class Scalar : public ScalarBase<Scalar, StatStor>
2203{
2204 public:
2205 using ScalarBase<Scalar, StatStor>::operator=;
2206};
2207
2208/**
2209 * A stat that calculates the per tick average of a value.
2210 * @sa Stat, ScalarBase, AvgStor
2211 */
2212class Average : public ScalarBase<Average, AvgStor>
2213{
2214 public:
2215 using ScalarBase<Average, AvgStor>::operator=;
2216};
2217
2218class Value : public ValueBase<Value>
2219{
2220};
2221
2222/**
2223 * A vector of scalar stats.
2224 * @sa Stat, VectorBase, StatStor
2225 */
2226class Vector : public VectorBase<Vector, StatStor>
2227{
2228};
2229
2230/**
2231 * A vector of Average stats.
2232 * @sa Stat, VectorBase, AvgStor
2233 */
2234class AverageVector : public VectorBase<AverageVector, AvgStor>
2235{
2236};
2237
2238/**
2239 * A 2-Dimensional vecto of scalar stats.
2240 * @sa Stat, Vector2dBase, StatStor
2241 */
2242class Vector2d : public Vector2dBase<Vector2d, StatStor>
2243{
2244};
2245
2246/**
2247 * A simple distribution stat.
2248 * @sa Stat, DistBase, DistStor
2249 */
2250class Distribution : public DistBase<Distribution, DistStor>
2251{
2252 public:
2253 /**
2254 * Set the parameters of this distribution. @sa DistStor::Params
2255 * @param min The minimum value of the distribution.
2256 * @param max The maximum value of the distribution.
2257 * @param bkt The number of values in each bucket.
2258 * @return A reference to this distribution.
2259 */
2260 Distribution &
2261 init(Counter min, Counter max, Counter bkt)
2262 {
2263 DistStor::Params *params = new DistStor::Params;
2264 params->min = min;
2265 params->max = max;
2266 params->bucket_size = bkt;
2267 params->buckets = (size_type)rint((max - min) / bkt + 1.0);
2268 this->setParams(params);
2269 this->doInit();
2270 return this->self();
2271 }
2272};
2273
2274/**
2275 * Calculates the mean and variance of all the samples.
2276 * @sa DistBase, SampleStor
2277 */
2278class StandardDeviation : public DistBase<StandardDeviation, SampleStor>
2279{
2280 public:
2281 /**
2282 * Construct and initialize this distribution.
2283 */
2284 StandardDeviation()
2285 {
2286 this->doInit();
2287 }
2288};
2289
2290/**
2291 * Calculates the per tick mean and variance of the samples.
2292 * @sa DistBase, AvgSampleStor
2293 */
2294class AverageDeviation : public DistBase<AverageDeviation, AvgSampleStor>
2295{
2296 public:
2297 /**
2298 * Construct and initialize this distribution.
2299 */
2300 AverageDeviation()
2301 {
2302 this->doInit();
2303 }
2304};
2305
2306/**
2307 * A vector of distributions.
2308 * @sa VectorDistBase, DistStor
2309 */
2310class VectorDistribution : public VectorDistBase<VectorDistribution, DistStor>
2311{
2312 public:
2313 /**
2314 * Initialize storage and parameters for this distribution.
2315 * @param size The size of the vector (the number of distributions).
2316 * @param min The minimum value of the distribution.
2317 * @param max The maximum value of the distribution.
2318 * @param bkt The number of values in each bucket.
2319 * @return A reference to this distribution.
2320 */
2321 VectorDistribution &
2322 init(size_type size, Counter min, Counter max, Counter bkt)
2323 {
2324 DistStor::Params *params = new DistStor::Params;
2325 params->min = min;
2326 params->max = max;
2327 params->bucket_size = bkt;
2328 params->buckets = (size_type)rint((max - min) / bkt + 1.0);
2329 this->setParams(params);
2330 this->doInit(size);
2331 return this->self();
2332 }
2333};
2334
2335/**
2336 * This is a vector of StandardDeviation stats.
2337 * @sa VectorDistBase, SampleStor
2338 */
2339class VectorStandardDeviation
2340 : public VectorDistBase<VectorStandardDeviation, SampleStor>
2341{
2342 public:
2343 /**
2344 * Initialize storage for this distribution.
2345 * @param size The size of the vector.
2346 * @return A reference to this distribution.
2347 */
2348 VectorStandardDeviation &
2349 init(size_type size)
2350 {
2351 this->doInit(size);
2352 return this->self();
2353 }
2354};
2355
2356/**
2357 * This is a vector of AverageDeviation stats.
2358 * @sa VectorDistBase, AvgSampleStor
2359 */
2360class VectorAverageDeviation
2361 : public VectorDistBase<VectorAverageDeviation, AvgSampleStor>
2362{
2363 public:
2364 /**
2365 * Initialize storage for this distribution.
2366 * @param size The size of the vector.
2367 * @return A reference to this distribution.
2368 */
2369 VectorAverageDeviation &
2370 init(size_type size)
2371 {
2372 this->doInit(size);
2373 return this->self();
2374 }
2375};
2376
2377template <class Stat>
2378class FormulaInfoProxy : public InfoProxy<Stat, FormulaInfo>
2379{
2380 protected:
2381 mutable VResult vec;
2382 mutable VCounter cvec;
2383
2384 public:
2385 FormulaInfoProxy(Stat &stat) : InfoProxy<Stat, FormulaInfo>(stat) {}
2386
2387 size_type size() const { return this->s.size(); }
2388
2389 const VResult &
2390 result() const
2391 {
2392 this->s.result(vec);
2393 return vec;
2394 }
2395 Result total() const { return this->s.total(); }
2396 VCounter &value() const { return cvec; }
2397
2398 std::string str() const { return this->s.str(); }
2399};
2400
2401class Temp;
2402/**
2403 * A formula for statistics that is calculated when printed. A formula is
2404 * stored as a tree of Nodes that represent the equation to calculate.
2405 * @sa Stat, ScalarStat, VectorStat, Node, Temp
2406 */
2407class Formula : public DataWrapVec<Formula, FormulaInfoProxy>
2408{
2409 protected:
2410 /** The root of the tree which represents the Formula */
2411 NodePtr root;
2412 friend class Temp;
2413
2414 public:
2415 /**
2416 * Create and initialize thie formula, and register it with the database.
2417 */
2418 Formula();
2419
2420 /**
2421 * Create a formula with the given root node, register it with the
2422 * database.
2423 * @param r The root of the expression tree.
2424 */
2425 Formula(Temp r);
2426
2427 /**
2428 * Set an unitialized Formula to the given root.
2429 * @param r The root of the expression tree.
2430 * @return a reference to this formula.
2431 */
2432 const Formula &operator=(Temp r);
2433
2434 /**
2435 * Add the given tree to the existing one.
2436 * @param r The root of the expression tree.
2437 * @return a reference to this formula.
2438 */
2439 const Formula &operator+=(Temp r);
2440 /**
2441 * Return the result of the Fomula in a vector. If there were no Vector
2442 * components to the Formula, then the vector is size 1. If there were,
2443 * like x/y with x being a vector of size 3, then the result returned will
2444 * be x[0]/y, x[1]/y, x[2]/y, respectively.
2445 * @return The result vector.
2446 */
2447 void result(VResult &vec) const;
2448
2449 /**
2450 * Return the total Formula result. If there is a Vector
2451 * component to this Formula, then this is the result of the
2452 * Formula if the formula is applied after summing all the
2453 * components of the Vector. For example, if Formula is x/y where
2454 * x is size 3, then total() will return (x[1]+x[2]+x[3])/y. If
2455 * there is no Vector component, total() returns the same value as
2456 * the first entry in the VResult val() returns.
2457 * @return The total of the result vector.
2458 */
2459 Result total() const;
2460
2461 /**
2462 * Return the number of elements in the tree.
2463 */
2464 size_type size() const;
2465
2466 void prepare() { }
2467
2468 /**
2469 * Formulas don't need to be reset
2470 */
2471 void reset();
2472
2473 /**
2474 *
2475 */
2476 bool zero() const;
2477
2478 std::string str() const;
2479};
2480
2481class FormulaNode : public Node
2482{
2483 private:
2484 const Formula &formula;
2485 mutable VResult vec;
2486
2487 public:
2488 FormulaNode(const Formula &f) : formula(f) {}
2489
2490 size_type size() const { return formula.size(); }
2491 const VResult &result() const { formula.result(vec); return vec; }
2492 Result total() const { return formula.total(); }
2493
2494 std::string str() const { return formula.str(); }
2495};
2496
2497/**
2498 * Helper class to construct formula node trees.
2499 */
2500class Temp
2501{
2502 protected:
2503 /**
2504 * Pointer to a Node object.
2505 */
2506 NodePtr node;
2507
2508 public:
2509 /**
2510 * Copy the given pointer to this class.
2511 * @param n A pointer to a Node object to copy.
2512 */
2513 Temp(NodePtr n) : node(n) { }
2514
2515 /**
2516 * Return the node pointer.
2517 * @return the node pointer.
2518 */
2519 operator NodePtr&() { return node; }
2520
2521 public:
2522 /**
2523 * Create a new ScalarStatNode.
2524 * @param s The ScalarStat to place in a node.
2525 */
2526 Temp(const Scalar &s)
2527 : node(new ScalarStatNode(s.info()))
2528 { }
2529
2530 /**
2531 * Create a new ScalarStatNode.
2532 * @param s The ScalarStat to place in a node.
2533 */
2534 Temp(const Value &s)
2535 : node(new ScalarStatNode(s.info()))
2536 { }
2537
2538 /**
2539 * Create a new ScalarStatNode.
2540 * @param s The ScalarStat to place in a node.
2541 */
2542 Temp(const Average &s)
2543 : node(new ScalarStatNode(s.info()))
2544 { }
2545
2546 /**
2547 * Create a new VectorStatNode.
2548 * @param s The VectorStat to place in a node.
2549 */
2550 Temp(const Vector &s)
2551 : node(new VectorStatNode(s.info()))
2552 { }
2553
| 579 }
580
581};
582
583/**
584 * Implementation of a scalar stat. The type of stat is determined by the
585 * Storage template.
586 */
587template <class Derived, class Stor>
588class ScalarBase : public DataWrap<Derived, ScalarInfoProxy>
589{
590 public:
591 typedef Stor Storage;
592 typedef typename Stor::Params Params;
593
594 protected:
595 /** The storage of this stat. */
596 char storage[sizeof(Storage)] __attribute__ ((aligned (8)));
597
598 protected:
599 /**
600 * Retrieve the storage.
601 * @param index The vector index to access.
602 * @return The storage object at the given index.
603 */
604 Storage *
605 data()
606 {
607 return reinterpret_cast<Storage *>(storage);
608 }
609
610 /**
611 * Retrieve a const pointer to the storage.
612 * for the given index.
613 * @param index The vector index to access.
614 * @return A const pointer to the storage object at the given index.
615 */
616 const Storage *
617 data() const
618 {
619 return reinterpret_cast<const Storage *>(storage);
620 }
621
622 void
623 doInit()
624 {
625 new (storage) Storage(this->info());
626 this->setInit();
627 }
628
629 public:
630 /**
631 * Return the current value of this stat as its base type.
632 * @return The current value.
633 */
634 Counter value() const { return data()->value(); }
635
636 public:
637 ScalarBase()
638 {
639 this->doInit();
640 }
641
642 public:
643 // Common operators for stats
644 /**
645 * Increment the stat by 1. This calls the associated storage object inc
646 * function.
647 */
648 void operator++() { data()->inc(1); }
649 /**
650 * Decrement the stat by 1. This calls the associated storage object dec
651 * function.
652 */
653 void operator--() { data()->dec(1); }
654
655 /** Increment the stat by 1. */
656 void operator++(int) { ++*this; }
657 /** Decrement the stat by 1. */
658 void operator--(int) { --*this; }
659
660 /**
661 * Set the data value to the given value. This calls the associated storage
662 * object set function.
663 * @param v The new value.
664 */
665 template <typename U>
666 void operator=(const U &v) { data()->set(v); }
667
668 /**
669 * Increment the stat by the given value. This calls the associated
670 * storage object inc function.
671 * @param v The value to add.
672 */
673 template <typename U>
674 void operator+=(const U &v) { data()->inc(v); }
675
676 /**
677 * Decrement the stat by the given value. This calls the associated
678 * storage object dec function.
679 * @param v The value to substract.
680 */
681 template <typename U>
682 void operator-=(const U &v) { data()->dec(v); }
683
684 /**
685 * Return the number of elements, always 1 for a scalar.
686 * @return 1.
687 */
688 size_type size() const { return 1; }
689
690 Counter value() { return data()->value(); }
691
692 Result result() { return data()->result(); }
693
694 Result total() { return result(); }
695
696 bool zero() { return result() == 0.0; }
697
698 void reset() { data()->reset(this->info()); }
699 void prepare() { data()->prepare(this->info()); }
700};
701
702class ProxyInfo : public ScalarInfo
703{
704 public:
705 std::string str() const { return to_string(value()); }
706 size_type size() const { return 1; }
707 bool check() const { return true; }
708 void prepare() { }
709 void reset() { }
710 bool zero() const { return value() == 0; }
711
712 void visit(Visit &visitor) { visitor.visit(*this); }
713};
714
715template <class T>
716class ValueProxy : public ProxyInfo
717{
718 private:
719 T *scalar;
720
721 public:
722 ValueProxy(T &val) : scalar(&val) {}
723 Counter value() const { return *scalar; }
724 Result result() const { return *scalar; }
725 Result total() const { return *scalar; }
726};
727
728template <class T>
729class FunctorProxy : public ProxyInfo
730{
731 private:
732 T *functor;
733
734 public:
735 FunctorProxy(T &func) : functor(&func) {}
736 Counter value() const { return (*functor)(); }
737 Result result() const { return (*functor)(); }
738 Result total() const { return (*functor)(); }
739};
740
741template <class Derived>
742class ValueBase : public DataWrap<Derived, ScalarInfoProxy>
743{
744 private:
745 ProxyInfo *proxy;
746
747 public:
748 ValueBase() : proxy(NULL) { }
749 ~ValueBase() { if (proxy) delete proxy; }
750
751 template <class T>
752 Derived &
753 scalar(T &value)
754 {
755 proxy = new ValueProxy<T>(value);
756 this->setInit();
757 return this->self();
758 }
759
760 template <class T>
761 Derived &
762 functor(T &func)
763 {
764 proxy = new FunctorProxy<T>(func);
765 this->setInit();
766 return this->self();
767 }
768
769 Counter value() { return proxy->value(); }
770 Result result() const { return proxy->result(); }
771 Result total() const { return proxy->total(); };
772 size_type size() const { return proxy->size(); }
773
774 std::string str() const { return proxy->str(); }
775 bool zero() const { return proxy->zero(); }
776 bool check() const { return proxy != NULL; }
777 void prepare() { }
778 void reset() { }
779};
780
781//////////////////////////////////////////////////////////////////////
782//
783// Vector Statistics
784//
785//////////////////////////////////////////////////////////////////////
786
787/**
788 * A proxy class to access the stat at a given index in a VectorBase stat.
789 * Behaves like a ScalarBase.
790 */
791template <class Stat>
792class ScalarProxy
793{
794 private:
795 /** Pointer to the parent Vector. */
796 Stat &stat;
797
798 /** The index to access in the parent VectorBase. */
799 off_type index;
800
801 public:
802 /**
803 * Return the current value of this stat as its base type.
804 * @return The current value.
805 */
806 Counter value() const { return stat.data(index)->value(); }
807
808 /**
809 * Return the current value of this statas a result type.
810 * @return The current value.
811 */
812 Result result() const { return stat.data(index)->result(); }
813
814 public:
815 /**
816 * Create and initialize this proxy, do not register it with the database.
817 * @param i The index to access.
818 */
819 ScalarProxy(Stat &s, off_type i)
820 : stat(s), index(i)
821 {
822 }
823
824 /**
825 * Create a copy of the provided ScalarProxy.
826 * @param sp The proxy to copy.
827 */
828 ScalarProxy(const ScalarProxy &sp)
829 : stat(sp.stat), index(sp.index)
830 {}
831
832 /**
833 * Set this proxy equal to the provided one.
834 * @param sp The proxy to copy.
835 * @return A reference to this proxy.
836 */
837 const ScalarProxy &
838 operator=(const ScalarProxy &sp)
839 {
840 stat = sp.stat;
841 index = sp.index;
842 return *this;
843 }
844
845 public:
846 // Common operators for stats
847 /**
848 * Increment the stat by 1. This calls the associated storage object inc
849 * function.
850 */
851 void operator++() { stat.data(index)->inc(1); }
852 /**
853 * Decrement the stat by 1. This calls the associated storage object dec
854 * function.
855 */
856 void operator--() { stat.data(index)->dec(1); }
857
858 /** Increment the stat by 1. */
859 void operator++(int) { ++*this; }
860 /** Decrement the stat by 1. */
861 void operator--(int) { --*this; }
862
863 /**
864 * Set the data value to the given value. This calls the associated storage
865 * object set function.
866 * @param v The new value.
867 */
868 template <typename U>
869 void
870 operator=(const U &v)
871 {
872 stat.data(index)->set(v);
873 }
874
875 /**
876 * Increment the stat by the given value. This calls the associated
877 * storage object inc function.
878 * @param v The value to add.
879 */
880 template <typename U>
881 void
882 operator+=(const U &v)
883 {
884 stat.data(index)->inc(v);
885 }
886
887 /**
888 * Decrement the stat by the given value. This calls the associated
889 * storage object dec function.
890 * @param v The value to substract.
891 */
892 template <typename U>
893 void
894 operator-=(const U &v)
895 {
896 stat.data(index)->dec(v);
897 }
898
899 /**
900 * Return the number of elements, always 1 for a scalar.
901 * @return 1.
902 */
903 size_type size() const { return 1; }
904
905 public:
906 std::string
907 str() const
908 {
909 return csprintf("%s[%d]", stat.info()->name, index);
910 }
911};
912
913/**
914 * Implementation of a vector of stats. The type of stat is determined by the
915 * Storage class. @sa ScalarBase
916 */
917template <class Derived, class Stor>
918class VectorBase : public DataWrapVec<Derived, VectorInfoProxy>
919{
920 public:
921 typedef Stor Storage;
922 typedef typename Stor::Params Params;
923
924 /** Proxy type */
925 typedef ScalarProxy<Derived> Proxy;
926 friend class ScalarProxy<Derived>;
927 friend class DataWrapVec<Derived, VectorInfoProxy>;
928
929 protected:
930 /** The storage of this stat. */
931 Storage *storage;
932 size_type _size;
933
934 protected:
935 /**
936 * Retrieve the storage.
937 * @param index The vector index to access.
938 * @return The storage object at the given index.
939 */
940 Storage *data(off_type index) { return &storage[index]; }
941
942 /**
943 * Retrieve a const pointer to the storage.
944 * @param index The vector index to access.
945 * @return A const pointer to the storage object at the given index.
946 */
947 const Storage *data(off_type index) const { return &storage[index]; }
948
949 void
950 doInit(size_type s)
951 {
952 assert(s > 0 && "size must be positive!");
953 assert(!storage && "already initialized");
954 _size = s;
955
956 char *ptr = new char[_size * sizeof(Storage)];
957 storage = reinterpret_cast<Storage *>(ptr);
958
959 for (off_type i = 0; i < _size; ++i)
960 new (&storage[i]) Storage(this->info());
961
962 this->setInit();
963 }
964
965 public:
966 void
967 value(VCounter &vec) const
968 {
969 vec.resize(size());
970 for (off_type i = 0; i < size(); ++i)
971 vec[i] = data(i)->value();
972 }
973
974 /**
975 * Copy the values to a local vector and return a reference to it.
976 * @return A reference to a vector of the stat values.
977 */
978 void
979 result(VResult &vec) const
980 {
981 vec.resize(size());
982 for (off_type i = 0; i < size(); ++i)
983 vec[i] = data(i)->result();
984 }
985
986 /**
987 * Return a total of all entries in this vector.
988 * @return The total of all vector entries.
989 */
990 Result
991 total() const
992 {
993 Result total = 0.0;
994 for (off_type i = 0; i < size(); ++i)
995 total += data(i)->result();
996 return total;
997 }
998
999 /**
1000 * @return the number of elements in this vector.
1001 */
1002 size_type size() const { return _size; }
1003
1004 bool
1005 zero() const
1006 {
1007 for (off_type i = 0; i < size(); ++i)
1008 if (data(i)->zero())
1009 return false;
1010 return true;
1011 }
1012
1013 bool
1014 check() const
1015 {
1016 return storage != NULL;
1017 }
1018
1019 public:
1020 VectorBase()
1021 : storage(NULL)
1022 {}
1023
1024 ~VectorBase()
1025 {
1026 if (!storage)
1027 return;
1028
1029 for (off_type i = 0; i < _size; ++i)
1030 data(i)->~Storage();
1031 delete [] reinterpret_cast<char *>(storage);
1032 }
1033
1034 /**
1035 * Set this vector to have the given size.
1036 * @param size The new size.
1037 * @return A reference to this stat.
1038 */
1039 Derived &
1040 init(size_type size)
1041 {
1042 Derived &self = this->self();
1043 self.doInit(size);
1044 return self;
1045 }
1046
1047 /**
1048 * Return a reference (ScalarProxy) to the stat at the given index.
1049 * @param index The vector index to access.
1050 * @return A reference of the stat.
1051 */
1052 Proxy
1053 operator[](off_type index)
1054 {
1055 assert (index >= 0 && index < size());
1056 return Proxy(this->self(), index);
1057 }
1058};
1059
1060template <class Stat>
1061class VectorProxy
1062{
1063 private:
1064 Stat &stat;
1065 off_type offset;
1066 size_type len;
1067
1068 private:
1069 mutable VResult vec;
1070
1071 typename Stat::Storage *
1072 data(off_type index)
1073 {
1074 assert(index < len);
1075 return stat.data(offset + index);
1076 }
1077
1078 const typename Stat::Storage *
1079 data(off_type index) const
1080 {
1081 assert(index < len);
1082 return stat.data(offset + index);
1083 }
1084
1085 public:
1086 const VResult &
1087 result() const
1088 {
1089 vec.resize(size());
1090
1091 for (off_type i = 0; i < size(); ++i)
1092 vec[i] = data(i)->result();
1093
1094 return vec;
1095 }
1096
1097 Result
1098 total() const
1099 {
1100 Result total = 0.0;
1101 for (off_type i = 0; i < size(); ++i)
1102 total += data(i)->result();
1103 return total;
1104 }
1105
1106 public:
1107 VectorProxy(Stat &s, off_type o, size_type l)
1108 : stat(s), offset(o), len(l)
1109 {
1110 }
1111
1112 VectorProxy(const VectorProxy &sp)
1113 : stat(sp.stat), offset(sp.offset), len(sp.len)
1114 {
1115 }
1116
1117 const VectorProxy &
1118 operator=(const VectorProxy &sp)
1119 {
1120 stat = sp.stat;
1121 offset = sp.offset;
1122 len = sp.len;
1123 return *this;
1124 }
1125
1126 ScalarProxy<Stat>
1127 operator[](off_type index)
1128 {
1129 assert (index >= 0 && index < size());
1130 return ScalarProxy<Stat>(stat, offset + index);
1131 }
1132
1133 size_type size() const { return len; }
1134};
1135
1136template <class Derived, class Stor>
1137class Vector2dBase : public DataWrapVec2d<Derived, Vector2dInfoProxy>
1138{
1139 public:
1140 typedef Vector2dInfoProxy<Derived> Info;
1141 typedef Stor Storage;
1142 typedef typename Stor::Params Params;
1143 typedef VectorProxy<Derived> Proxy;
1144 friend class ScalarProxy<Derived>;
1145 friend class VectorProxy<Derived>;
1146 friend class DataWrapVec<Derived, Vector2dInfoProxy>;
1147 friend class DataWrapVec2d<Derived, Vector2dInfoProxy>;
1148
1149 protected:
1150 size_type x;
1151 size_type y;
1152 size_type _size;
1153 Storage *storage;
1154
1155 protected:
1156 Storage *data(off_type index) { return &storage[index]; }
1157 const Storage *data(off_type index) const { return &storage[index]; }
1158
1159 public:
1160 Vector2dBase()
1161 : storage(NULL)
1162 {}
1163
1164 ~Vector2dBase()
1165 {
1166 if (!storage)
1167 return;
1168
1169 for (off_type i = 0; i < _size; ++i)
1170 data(i)->~Storage();
1171 delete [] reinterpret_cast<char *>(storage);
1172 }
1173
1174 Derived &
1175 init(size_type _x, size_type _y)
1176 {
1177 assert(_x > 0 && _y > 0 && "sizes must be positive!");
1178 assert(!storage && "already initialized");
1179
1180 Derived &self = this->self();
1181 Info *info = this->info();
1182
1183 x = _x;
1184 y = _y;
1185 info->x = _x;
1186 info->y = _y;
1187 _size = x * y;
1188
1189 char *ptr = new char[_size * sizeof(Storage)];
1190 storage = reinterpret_cast<Storage *>(ptr);
1191
1192 for (off_type i = 0; i < _size; ++i)
1193 new (&storage[i]) Storage(info);
1194
1195 this->setInit();
1196
1197 return self;
1198 }
1199
1200 std::string ysubname(off_type i) const { return (*this->y_subnames)[i]; }
1201
1202 Proxy
1203 operator[](off_type index)
1204 {
1205 off_type offset = index * y;
1206 assert (index >= 0 && offset + index < size());
1207 return Proxy(this->self(), offset, y);
1208 }
1209
1210
1211 size_type
1212 size() const
1213 {
1214 return _size;
1215 }
1216
1217 bool
1218 zero() const
1219 {
1220 return data(0)->zero();
1221#if 0
1222 for (off_type i = 0; i < size(); ++i)
1223 if (!data(i)->zero())
1224 return false;
1225 return true;
1226#endif
1227 }
1228
1229 void
1230 prepare()
1231 {
1232 Info *info = this->info();
1233 size_type size = this->size();
1234
1235 for (off_type i = 0; i < size; ++i)
1236 data(i)->prepare(info);
1237
1238 info->cvec.resize(size);
1239 for (off_type i = 0; i < size; ++i)
1240 info->cvec[i] = data(i)->value();
1241 }
1242
1243 /**
1244 * Reset stat value to default
1245 */
1246 void
1247 reset()
1248 {
1249 Info *info = this->info();
1250 size_type size = this->size();
1251 for (off_type i = 0; i < size; ++i)
1252 data(i)->reset(info);
1253 }
1254
1255 bool
1256 check() const
1257 {
1258 return storage != NULL;
1259 }
1260};
1261
1262//////////////////////////////////////////////////////////////////////
1263//
1264// Non formula statistics
1265//
1266//////////////////////////////////////////////////////////////////////
1267
1268/**
1269 * Templatized storage and interface for a distrbution stat.
1270 */
1271class DistStor
1272{
1273 public:
1274 /** The parameters for a distribution stat. */
1275 struct Params : public DistParams
1276 {
1277 Params() : DistParams(Dist) {}
1278 };
1279
1280 private:
1281 /** The minimum value to track. */
1282 Counter min_track;
1283 /** The maximum value to track. */
1284 Counter max_track;
1285 /** The number of entries in each bucket. */
1286 Counter bucket_size;
1287 /** The number of buckets. Equal to (max-min)/bucket_size. */
1288 size_type buckets;
1289
1290 /** The smallest value sampled. */
1291 Counter min_val;
1292 /** The largest value sampled. */
1293 Counter max_val;
1294 /** The number of values sampled less than min. */
1295 Counter underflow;
1296 /** The number of values sampled more than max. */
1297 Counter overflow;
1298 /** The current sum. */
1299 Counter sum;
1300 /** The sum of squares. */
1301 Counter squares;
1302 /** The number of samples. */
1303 Counter samples;
1304 /** Counter for each bucket. */
1305 VCounter cvec;
1306
1307 public:
1308 DistStor(Info *info)
1309 : cvec(safe_cast<const Params *>(info->storageParams)->buckets)
1310 {
1311 reset(info);
1312 }
1313
1314 /**
1315 * Add a value to the distribution for the given number of times.
1316 * @param val The value to add.
1317 * @param number The number of times to add the value.
1318 */
1319 void
1320 sample(Counter val, int number)
1321 {
1322 if (val < min_track)
1323 underflow += number;
1324 else if (val > max_track)
1325 overflow += number;
1326 else {
1327 size_type index =
1328 (size_type)std::floor((val - min_track) / bucket_size);
1329 assert(index < size());
1330 cvec[index] += number;
1331 }
1332
1333 if (val < min_val)
1334 min_val = val;
1335
1336 if (val > max_val)
1337 max_val = val;
1338
1339 Counter sample = val * number;
1340 sum += sample;
1341 squares += sample * sample;
1342 samples += number;
1343 }
1344
1345 /**
1346 * Return the number of buckets in this distribution.
1347 * @return the number of buckets.
1348 */
1349 size_type size() const { return cvec.size(); }
1350
1351 /**
1352 * Returns true if any calls to sample have been made.
1353 * @return True if any values have been sampled.
1354 */
1355 bool
1356 zero() const
1357 {
1358 return samples == Counter();
1359 }
1360
1361 void
1362 prepare(Info *info, DistData &data)
1363 {
1364 const Params *params = safe_cast<const Params *>(info->storageParams);
1365
1366 data.min_val = (min_val == CounterLimits::max()) ? 0 : min_val;
1367 data.max_val = (max_val == CounterLimits::min()) ? 0 : max_val;
1368 data.underflow = underflow;
1369 data.overflow = overflow;
1370
1371 size_type buckets = params->buckets;
1372 data.cvec.resize(buckets);
1373 for (off_type i = 0; i < buckets; ++i)
1374 data.cvec[i] = cvec[i];
1375
1376 data.sum = sum;
1377 data.squares = squares;
1378 data.samples = samples;
1379 }
1380
1381 /**
1382 * Reset stat value to default
1383 */
1384 void
1385 reset(Info *info)
1386 {
1387 const Params *params = safe_cast<const Params *>(info->storageParams);
1388 min_track = params->min;
1389 max_track = params->max;
1390 bucket_size = params->bucket_size;
1391
1392 min_val = CounterLimits::max();
1393 max_val = CounterLimits::min();
1394 underflow = Counter();
1395 overflow = Counter();
1396
1397 size_type size = cvec.size();
1398 for (off_type i = 0; i < size; ++i)
1399 cvec[i] = Counter();
1400
1401 sum = Counter();
1402 squares = Counter();
1403 samples = Counter();
1404 }
1405};
1406
1407/**
1408 * Templatized storage and interface for a distribution that calculates mean
1409 * and variance.
1410 */
1411class SampleStor
1412{
1413 public:
1414 struct Params : public DistParams
1415 {
1416 Params() : DistParams(Deviation) {}
1417 };
1418
1419 private:
1420 /** The current sum. */
1421 Counter sum;
1422 /** The sum of squares. */
1423 Counter squares;
1424 /** The number of samples. */
1425 Counter samples;
1426
1427 public:
1428 /**
1429 * Create and initialize this storage.
1430 */
1431 SampleStor(Info *info)
1432 : sum(Counter()), squares(Counter()), samples(Counter())
1433 { }
1434
1435 /**
1436 * Add a value the given number of times to this running average.
1437 * Update the running sum and sum of squares, increment the number of
1438 * values seen by the given number.
1439 * @param val The value to add.
1440 * @param number The number of times to add the value.
1441 */
1442 void
1443 sample(Counter val, int number)
1444 {
1445 Counter value = val * number;
1446 sum += value;
1447 squares += value * value;
1448 samples += number;
1449 }
1450
1451 /**
1452 * Return the number of entries in this stat, 1
1453 * @return 1.
1454 */
1455 size_type size() const { return 1; }
1456
1457 /**
1458 * Return true if no samples have been added.
1459 * @return True if no samples have been added.
1460 */
1461 bool zero() const { return samples == Counter(); }
1462
1463 void
1464 prepare(Info *info, DistData &data)
1465 {
1466 data.sum = sum;
1467 data.squares = squares;
1468 data.samples = samples;
1469 }
1470
1471 /**
1472 * Reset stat value to default
1473 */
1474 void
1475 reset(Info *info)
1476 {
1477 sum = Counter();
1478 squares = Counter();
1479 samples = Counter();
1480 }
1481};
1482
1483/**
1484 * Templatized storage for distribution that calculates per tick mean and
1485 * variance.
1486 */
1487class AvgSampleStor
1488{
1489 public:
1490 struct Params : public DistParams
1491 {
1492 Params() : DistParams(Deviation) {}
1493 };
1494
1495 private:
1496 /** Current total. */
1497 Counter sum;
1498 /** Current sum of squares. */
1499 Counter squares;
1500
1501 public:
1502 /**
1503 * Create and initialize this storage.
1504 */
1505 AvgSampleStor(Info *info)
1506 : sum(Counter()), squares(Counter())
1507 {}
1508
1509 /**
1510 * Add a value to the distribution for the given number of times.
1511 * Update the running sum and sum of squares.
1512 * @param val The value to add.
1513 * @param number The number of times to add the value.
1514 */
1515 void
1516 sample(Counter val, int number)
1517 {
1518 Counter value = val * number;
1519 sum += value;
1520 squares += value * value;
1521 }
1522
1523 /**
1524 * Return the number of entries, in this case 1.
1525 * @return 1.
1526 */
1527 size_type size() const { return 1; }
1528
1529 /**
1530 * Return true if no samples have been added.
1531 * @return True if the sum is zero.
1532 */
1533 bool zero() const { return sum == Counter(); }
1534
1535 void
1536 prepare(Info *info, DistData &data)
1537 {
1538 data.sum = sum;
1539 data.squares = squares;
1540 data.samples = curTick;
1541 }
1542
1543 /**
1544 * Reset stat value to default
1545 */
1546 void
1547 reset(Info *info)
1548 {
1549 sum = Counter();
1550 squares = Counter();
1551 }
1552};
1553
1554/**
1555 * Implementation of a distribution stat. The type of distribution is
1556 * determined by the Storage template. @sa ScalarBase
1557 */
1558template <class Derived, class Stor>
1559class DistBase : public DataWrap<Derived, DistInfoProxy>
1560{
1561 public:
1562 typedef DistInfoProxy<Derived> Info;
1563 typedef Stor Storage;
1564 typedef typename Stor::Params Params;
1565
1566 protected:
1567 /** The storage for this stat. */
1568 char storage[sizeof(Storage)] __attribute__ ((aligned (8)));
1569
1570 protected:
1571 /**
1572 * Retrieve the storage.
1573 * @return The storage object for this stat.
1574 */
1575 Storage *
1576 data()
1577 {
1578 return reinterpret_cast<Storage *>(storage);
1579 }
1580
1581 /**
1582 * Retrieve a const pointer to the storage.
1583 * @return A const pointer to the storage object for this stat.
1584 */
1585 const Storage *
1586 data() const
1587 {
1588 return reinterpret_cast<const Storage *>(storage);
1589 }
1590
1591 void
1592 doInit()
1593 {
1594 new (storage) Storage(this->info());
1595 this->setInit();
1596 }
1597
1598 public:
1599 DistBase() { }
1600
1601 /**
1602 * Add a value to the distribtion n times. Calls sample on the storage
1603 * class.
1604 * @param v The value to add.
1605 * @param n The number of times to add it, defaults to 1.
1606 */
1607 template <typename U>
1608 void sample(const U &v, int n = 1) { data()->sample(v, n); }
1609
1610 /**
1611 * Return the number of entries in this stat.
1612 * @return The number of entries.
1613 */
1614 size_type size() const { return data()->size(); }
1615 /**
1616 * Return true if no samples have been added.
1617 * @return True if there haven't been any samples.
1618 */
1619 bool zero() const { return data()->zero(); }
1620
1621 void
1622 prepare()
1623 {
1624 Info *info = this->info();
1625 data()->prepare(info, info->data);
1626 }
1627
1628 /**
1629 * Reset stat value to default
1630 */
1631 void
1632 reset()
1633 {
1634 data()->reset(this->info());
1635 }
1636};
1637
1638template <class Stat>
1639class DistProxy;
1640
1641template <class Derived, class Stor>
1642class VectorDistBase : public DataWrapVec<Derived, VectorDistInfoProxy>
1643{
1644 public:
1645 typedef VectorDistInfoProxy<Derived> Info;
1646 typedef Stor Storage;
1647 typedef typename Stor::Params Params;
1648 typedef DistProxy<Derived> Proxy;
1649 friend class DistProxy<Derived>;
1650 friend class DataWrapVec<Derived, VectorDistInfoProxy>;
1651
1652 protected:
1653 Storage *storage;
1654 size_type _size;
1655
1656 protected:
1657 Storage *
1658 data(off_type index)
1659 {
1660 return &storage[index];
1661 }
1662
1663 const Storage *
1664 data(off_type index) const
1665 {
1666 return &storage[index];
1667 }
1668
1669 void
1670 doInit(size_type s)
1671 {
1672 assert(s > 0 && "size must be positive!");
1673 assert(!storage && "already initialized");
1674 _size = s;
1675
1676 char *ptr = new char[_size * sizeof(Storage)];
1677 storage = reinterpret_cast<Storage *>(ptr);
1678
1679 Info *info = this->info();
1680 for (off_type i = 0; i < _size; ++i)
1681 new (&storage[i]) Storage(info);
1682
1683 this->setInit();
1684 }
1685
1686 public:
1687 VectorDistBase()
1688 : storage(NULL)
1689 {}
1690
1691 ~VectorDistBase()
1692 {
1693 if (!storage)
1694 return ;
1695
1696 for (off_type i = 0; i < _size; ++i)
1697 data(i)->~Storage();
1698 delete [] reinterpret_cast<char *>(storage);
1699 }
1700
1701 Proxy operator[](off_type index);
1702
1703 size_type
1704 size() const
1705 {
1706 return _size;
1707 }
1708
1709 bool
1710 zero() const
1711 {
1712 return false;
1713#if 0
1714 for (off_type i = 0; i < size(); ++i)
1715 if (!data(i)->zero())
1716 return false;
1717 return true;
1718#endif
1719 }
1720
1721 void
1722 prepare()
1723 {
1724 Info *info = this->info();
1725 size_type size = this->size();
1726 info->data.resize(size);
1727 for (off_type i = 0; i < size; ++i)
1728 data(i)->prepare(info, info->data[i]);
1729 }
1730
1731 bool
1732 check() const
1733 {
1734 return storage != NULL;
1735 }
1736};
1737
1738template <class Stat>
1739class DistProxy
1740{
1741 private:
1742 Stat *stat;
1743 off_type index;
1744
1745 protected:
1746 typename Stat::Storage *data() { return stat->data(index); }
1747 const typename Stat::Storage *data() const { return stat->data(index); }
1748
1749 public:
1750 DistProxy(Stat *s, off_type i)
1751 : stat(s), index(i)
1752 {}
1753
1754 DistProxy(const DistProxy &sp)
1755 : stat(sp.stat), index(sp.index)
1756 {}
1757
1758 const DistProxy &
1759 operator=(const DistProxy &sp)
1760 {
1761 stat = sp.stat;
1762 index = sp.index;
1763 return *this;
1764 }
1765
1766 public:
1767 template <typename U>
1768 void
1769 sample(const U &v, int n = 1)
1770 {
1771 data()->sample(v, n);
1772 }
1773
1774 size_type
1775 size() const
1776 {
1777 return 1;
1778 }
1779
1780 bool
1781 zero() const
1782 {
1783 return data()->zero();
1784 }
1785
1786 /**
1787 * Proxy has no state. Nothing to reset.
1788 */
1789 void reset() { }
1790};
1791
1792template <class Derived, class Stor>
1793inline typename VectorDistBase<Derived, Stor>::Proxy
1794VectorDistBase<Derived, Stor>::operator[](off_type index)
1795{
1796 assert (index >= 0 && index < size());
1797 typedef typename VectorDistBase<Derived, Stor>::Proxy Proxy;
1798 return Proxy(this, index);
1799}
1800
1801#if 0
1802template <class Storage>
1803Result
1804VectorDistBase<Storage>::total(off_type index) const
1805{
1806 Result total = 0.0;
1807 for (off_type i = 0; i < x_size(); ++i)
1808 total += data(i)->result();
1809}
1810#endif
1811
1812//////////////////////////////////////////////////////////////////////
1813//
1814// Formula Details
1815//
1816//////////////////////////////////////////////////////////////////////
1817
1818/**
1819 * Base class for formula statistic node. These nodes are used to build a tree
1820 * that represents the formula.
1821 */
1822class Node : public RefCounted
1823{
1824 public:
1825 /**
1826 * Return the number of nodes in the subtree starting at this node.
1827 * @return the number of nodes in this subtree.
1828 */
1829 virtual size_type size() const = 0;
1830 /**
1831 * Return the result vector of this subtree.
1832 * @return The result vector of this subtree.
1833 */
1834 virtual const VResult &result() const = 0;
1835 /**
1836 * Return the total of the result vector.
1837 * @return The total of the result vector.
1838 */
1839 virtual Result total() const = 0;
1840
1841 /**
1842 *
1843 */
1844 virtual std::string str() const = 0;
1845};
1846
1847/** Reference counting pointer to a function Node. */
1848typedef RefCountingPtr<Node> NodePtr;
1849
1850class ScalarStatNode : public Node
1851{
1852 private:
1853 const ScalarInfo *data;
1854 mutable VResult vresult;
1855
1856 public:
1857 ScalarStatNode(const ScalarInfo *d) : data(d), vresult(1) {}
1858
1859 const VResult &
1860 result() const
1861 {
1862 vresult[0] = data->result();
1863 return vresult;
1864 }
1865
1866 Result total() const { return data->result(); };
1867
1868 size_type size() const { return 1; }
1869
1870 /**
1871 *
1872 */
1873 std::string str() const { return data->name; }
1874};
1875
1876template <class Stat>
1877class ScalarProxyNode : public Node
1878{
1879 private:
1880 const ScalarProxy<Stat> proxy;
1881 mutable VResult vresult;
1882
1883 public:
1884 ScalarProxyNode(const ScalarProxy<Stat> &p)
1885 : proxy(p), vresult(1)
1886 { }
1887
1888 const VResult &
1889 result() const
1890 {
1891 vresult[0] = proxy.result();
1892 return vresult;
1893 }
1894
1895 Result
1896 total() const
1897 {
1898 return proxy.result();
1899 }
1900
1901 size_type
1902 size() const
1903 {
1904 return 1;
1905 }
1906
1907 /**
1908 *
1909 */
1910 std::string
1911 str() const
1912 {
1913 return proxy.str();
1914 }
1915};
1916
1917class VectorStatNode : public Node
1918{
1919 private:
1920 const VectorInfo *data;
1921
1922 public:
1923 VectorStatNode(const VectorInfo *d) : data(d) { }
1924 const VResult &result() const { return data->result(); }
1925 Result total() const { return data->total(); };
1926
1927 size_type size() const { return data->size(); }
1928
1929 std::string str() const { return data->name; }
1930};
1931
1932template <class T>
1933class ConstNode : public Node
1934{
1935 private:
1936 VResult vresult;
1937
1938 public:
1939 ConstNode(T s) : vresult(1, (Result)s) {}
1940 const VResult &result() const { return vresult; }
1941 Result total() const { return vresult[0]; };
1942 size_type size() const { return 1; }
1943 std::string str() const { return to_string(vresult[0]); }
1944};
1945
1946template <class T>
1947class ConstVectorNode : public Node
1948{
1949 private:
1950 VResult vresult;
1951
1952 public:
1953 ConstVectorNode(const T &s) : vresult(s.begin(), s.end()) {}
1954 const VResult &result() const { return vresult; }
1955
1956 Result
1957 total() const
1958 {
1959 size_type size = this->size();
1960 Result tmp = 0;
1961 for (off_type i = 0; i < size; i++)
1962 tmp += vresult[i];
1963 return tmp;
1964 }
1965
1966 size_type size() const { return vresult.size(); }
1967 std::string
1968 str() const
1969 {
1970 size_type size = this->size();
1971 std::string tmp = "(";
1972 for (off_type i = 0; i < size; i++)
1973 tmp += csprintf("%s ",to_string(vresult[i]));
1974 tmp += ")";
1975 return tmp;
1976 }
1977};
1978
1979template <class Op>
1980struct OpString;
1981
1982template<>
1983struct OpString<std::plus<Result> >
1984{
1985 static std::string str() { return "+"; }
1986};
1987
1988template<>
1989struct OpString<std::minus<Result> >
1990{
1991 static std::string str() { return "-"; }
1992};
1993
1994template<>
1995struct OpString<std::multiplies<Result> >
1996{
1997 static std::string str() { return "*"; }
1998};
1999
2000template<>
2001struct OpString<std::divides<Result> >
2002{
2003 static std::string str() { return "/"; }
2004};
2005
2006template<>
2007struct OpString<std::modulus<Result> >
2008{
2009 static std::string str() { return "%"; }
2010};
2011
2012template<>
2013struct OpString<std::negate<Result> >
2014{
2015 static std::string str() { return "-"; }
2016};
2017
2018template <class Op>
2019class UnaryNode : public Node
2020{
2021 public:
2022 NodePtr l;
2023 mutable VResult vresult;
2024
2025 public:
2026 UnaryNode(NodePtr &p) : l(p) {}
2027
2028 const VResult &
2029 result() const
2030 {
2031 const VResult &lvec = l->result();
2032 size_type size = lvec.size();
2033
2034 assert(size > 0);
2035
2036 vresult.resize(size);
2037 Op op;
2038 for (off_type i = 0; i < size; ++i)
2039 vresult[i] = op(lvec[i]);
2040
2041 return vresult;
2042 }
2043
2044 Result
2045 total() const
2046 {
2047 const VResult &vec = this->result();
2048 Result total = 0.0;
2049 for (off_type i = 0; i < size(); i++)
2050 total += vec[i];
2051 return total;
2052 }
2053
2054 size_type size() const { return l->size(); }
2055
2056 std::string
2057 str() const
2058 {
2059 return OpString<Op>::str() + l->str();
2060 }
2061};
2062
2063template <class Op>
2064class BinaryNode : public Node
2065{
2066 public:
2067 NodePtr l;
2068 NodePtr r;
2069 mutable VResult vresult;
2070
2071 public:
2072 BinaryNode(NodePtr &a, NodePtr &b) : l(a), r(b) {}
2073
2074 const VResult &
2075 result() const
2076 {
2077 Op op;
2078 const VResult &lvec = l->result();
2079 const VResult &rvec = r->result();
2080
2081 assert(lvec.size() > 0 && rvec.size() > 0);
2082
2083 if (lvec.size() == 1 && rvec.size() == 1) {
2084 vresult.resize(1);
2085 vresult[0] = op(lvec[0], rvec[0]);
2086 } else if (lvec.size() == 1) {
2087 size_type size = rvec.size();
2088 vresult.resize(size);
2089 for (off_type i = 0; i < size; ++i)
2090 vresult[i] = op(lvec[0], rvec[i]);
2091 } else if (rvec.size() == 1) {
2092 size_type size = lvec.size();
2093 vresult.resize(size);
2094 for (off_type i = 0; i < size; ++i)
2095 vresult[i] = op(lvec[i], rvec[0]);
2096 } else if (rvec.size() == lvec.size()) {
2097 size_type size = rvec.size();
2098 vresult.resize(size);
2099 for (off_type i = 0; i < size; ++i)
2100 vresult[i] = op(lvec[i], rvec[i]);
2101 }
2102
2103 return vresult;
2104 }
2105
2106 Result
2107 total() const
2108 {
2109 const VResult &vec = this->result();
2110 Result total = 0.0;
2111 for (off_type i = 0; i < size(); i++)
2112 total += vec[i];
2113 return total;
2114 }
2115
2116 size_type
2117 size() const
2118 {
2119 size_type ls = l->size();
2120 size_type rs = r->size();
2121 if (ls == 1) {
2122 return rs;
2123 } else if (rs == 1) {
2124 return ls;
2125 } else {
2126 assert(ls == rs && "Node vector sizes are not equal");
2127 return ls;
2128 }
2129 }
2130
2131 std::string
2132 str() const
2133 {
2134 return csprintf("(%s %s %s)", l->str(), OpString<Op>::str(), r->str());
2135 }
2136};
2137
2138template <class Op>
2139class SumNode : public Node
2140{
2141 public:
2142 NodePtr l;
2143 mutable VResult vresult;
2144
2145 public:
2146 SumNode(NodePtr &p) : l(p), vresult(1) {}
2147
2148 const VResult &
2149 result() const
2150 {
2151 const VResult &lvec = l->result();
2152 size_type size = lvec.size();
2153 assert(size > 0);
2154
2155 vresult[0] = 0.0;
2156
2157 Op op;
2158 for (off_type i = 0; i < size; ++i)
2159 vresult[0] = op(vresult[0], lvec[i]);
2160
2161 return vresult;
2162 }
2163
2164 Result
2165 total() const
2166 {
2167 const VResult &lvec = l->result();
2168 size_type size = lvec.size();
2169 assert(size > 0);
2170
2171 Result vresult = 0.0;
2172
2173 Op op;
2174 for (off_type i = 0; i < size; ++i)
2175 vresult = op(vresult, lvec[i]);
2176
2177 return vresult;
2178 }
2179
2180 size_type size() const { return 1; }
2181
2182 std::string
2183 str() const
2184 {
2185 return csprintf("total(%s)", l->str());
2186 }
2187};
2188
2189
2190//////////////////////////////////////////////////////////////////////
2191//
2192// Visible Statistics Types
2193//
2194//////////////////////////////////////////////////////////////////////
2195/**
2196 * @defgroup VisibleStats "Statistic Types"
2197 * These are the statistics that are used in the simulator.
2198 * @{
2199 */
2200
2201/**
2202 * This is a simple scalar statistic, like a counter.
2203 * @sa Stat, ScalarBase, StatStor
2204 */
2205class Scalar : public ScalarBase<Scalar, StatStor>
2206{
2207 public:
2208 using ScalarBase<Scalar, StatStor>::operator=;
2209};
2210
2211/**
2212 * A stat that calculates the per tick average of a value.
2213 * @sa Stat, ScalarBase, AvgStor
2214 */
2215class Average : public ScalarBase<Average, AvgStor>
2216{
2217 public:
2218 using ScalarBase<Average, AvgStor>::operator=;
2219};
2220
2221class Value : public ValueBase<Value>
2222{
2223};
2224
2225/**
2226 * A vector of scalar stats.
2227 * @sa Stat, VectorBase, StatStor
2228 */
2229class Vector : public VectorBase<Vector, StatStor>
2230{
2231};
2232
2233/**
2234 * A vector of Average stats.
2235 * @sa Stat, VectorBase, AvgStor
2236 */
2237class AverageVector : public VectorBase<AverageVector, AvgStor>
2238{
2239};
2240
2241/**
2242 * A 2-Dimensional vecto of scalar stats.
2243 * @sa Stat, Vector2dBase, StatStor
2244 */
2245class Vector2d : public Vector2dBase<Vector2d, StatStor>
2246{
2247};
2248
2249/**
2250 * A simple distribution stat.
2251 * @sa Stat, DistBase, DistStor
2252 */
2253class Distribution : public DistBase<Distribution, DistStor>
2254{
2255 public:
2256 /**
2257 * Set the parameters of this distribution. @sa DistStor::Params
2258 * @param min The minimum value of the distribution.
2259 * @param max The maximum value of the distribution.
2260 * @param bkt The number of values in each bucket.
2261 * @return A reference to this distribution.
2262 */
2263 Distribution &
2264 init(Counter min, Counter max, Counter bkt)
2265 {
2266 DistStor::Params *params = new DistStor::Params;
2267 params->min = min;
2268 params->max = max;
2269 params->bucket_size = bkt;
2270 params->buckets = (size_type)rint((max - min) / bkt + 1.0);
2271 this->setParams(params);
2272 this->doInit();
2273 return this->self();
2274 }
2275};
2276
2277/**
2278 * Calculates the mean and variance of all the samples.
2279 * @sa DistBase, SampleStor
2280 */
2281class StandardDeviation : public DistBase<StandardDeviation, SampleStor>
2282{
2283 public:
2284 /**
2285 * Construct and initialize this distribution.
2286 */
2287 StandardDeviation()
2288 {
2289 this->doInit();
2290 }
2291};
2292
2293/**
2294 * Calculates the per tick mean and variance of the samples.
2295 * @sa DistBase, AvgSampleStor
2296 */
2297class AverageDeviation : public DistBase<AverageDeviation, AvgSampleStor>
2298{
2299 public:
2300 /**
2301 * Construct and initialize this distribution.
2302 */
2303 AverageDeviation()
2304 {
2305 this->doInit();
2306 }
2307};
2308
2309/**
2310 * A vector of distributions.
2311 * @sa VectorDistBase, DistStor
2312 */
2313class VectorDistribution : public VectorDistBase<VectorDistribution, DistStor>
2314{
2315 public:
2316 /**
2317 * Initialize storage and parameters for this distribution.
2318 * @param size The size of the vector (the number of distributions).
2319 * @param min The minimum value of the distribution.
2320 * @param max The maximum value of the distribution.
2321 * @param bkt The number of values in each bucket.
2322 * @return A reference to this distribution.
2323 */
2324 VectorDistribution &
2325 init(size_type size, Counter min, Counter max, Counter bkt)
2326 {
2327 DistStor::Params *params = new DistStor::Params;
2328 params->min = min;
2329 params->max = max;
2330 params->bucket_size = bkt;
2331 params->buckets = (size_type)rint((max - min) / bkt + 1.0);
2332 this->setParams(params);
2333 this->doInit(size);
2334 return this->self();
2335 }
2336};
2337
2338/**
2339 * This is a vector of StandardDeviation stats.
2340 * @sa VectorDistBase, SampleStor
2341 */
2342class VectorStandardDeviation
2343 : public VectorDistBase<VectorStandardDeviation, SampleStor>
2344{
2345 public:
2346 /**
2347 * Initialize storage for this distribution.
2348 * @param size The size of the vector.
2349 * @return A reference to this distribution.
2350 */
2351 VectorStandardDeviation &
2352 init(size_type size)
2353 {
2354 this->doInit(size);
2355 return this->self();
2356 }
2357};
2358
2359/**
2360 * This is a vector of AverageDeviation stats.
2361 * @sa VectorDistBase, AvgSampleStor
2362 */
2363class VectorAverageDeviation
2364 : public VectorDistBase<VectorAverageDeviation, AvgSampleStor>
2365{
2366 public:
2367 /**
2368 * Initialize storage for this distribution.
2369 * @param size The size of the vector.
2370 * @return A reference to this distribution.
2371 */
2372 VectorAverageDeviation &
2373 init(size_type size)
2374 {
2375 this->doInit(size);
2376 return this->self();
2377 }
2378};
2379
2380template <class Stat>
2381class FormulaInfoProxy : public InfoProxy<Stat, FormulaInfo>
2382{
2383 protected:
2384 mutable VResult vec;
2385 mutable VCounter cvec;
2386
2387 public:
2388 FormulaInfoProxy(Stat &stat) : InfoProxy<Stat, FormulaInfo>(stat) {}
2389
2390 size_type size() const { return this->s.size(); }
2391
2392 const VResult &
2393 result() const
2394 {
2395 this->s.result(vec);
2396 return vec;
2397 }
2398 Result total() const { return this->s.total(); }
2399 VCounter &value() const { return cvec; }
2400
2401 std::string str() const { return this->s.str(); }
2402};
2403
2404class Temp;
2405/**
2406 * A formula for statistics that is calculated when printed. A formula is
2407 * stored as a tree of Nodes that represent the equation to calculate.
2408 * @sa Stat, ScalarStat, VectorStat, Node, Temp
2409 */
2410class Formula : public DataWrapVec<Formula, FormulaInfoProxy>
2411{
2412 protected:
2413 /** The root of the tree which represents the Formula */
2414 NodePtr root;
2415 friend class Temp;
2416
2417 public:
2418 /**
2419 * Create and initialize thie formula, and register it with the database.
2420 */
2421 Formula();
2422
2423 /**
2424 * Create a formula with the given root node, register it with the
2425 * database.
2426 * @param r The root of the expression tree.
2427 */
2428 Formula(Temp r);
2429
2430 /**
2431 * Set an unitialized Formula to the given root.
2432 * @param r The root of the expression tree.
2433 * @return a reference to this formula.
2434 */
2435 const Formula &operator=(Temp r);
2436
2437 /**
2438 * Add the given tree to the existing one.
2439 * @param r The root of the expression tree.
2440 * @return a reference to this formula.
2441 */
2442 const Formula &operator+=(Temp r);
2443 /**
2444 * Return the result of the Fomula in a vector. If there were no Vector
2445 * components to the Formula, then the vector is size 1. If there were,
2446 * like x/y with x being a vector of size 3, then the result returned will
2447 * be x[0]/y, x[1]/y, x[2]/y, respectively.
2448 * @return The result vector.
2449 */
2450 void result(VResult &vec) const;
2451
2452 /**
2453 * Return the total Formula result. If there is a Vector
2454 * component to this Formula, then this is the result of the
2455 * Formula if the formula is applied after summing all the
2456 * components of the Vector. For example, if Formula is x/y where
2457 * x is size 3, then total() will return (x[1]+x[2]+x[3])/y. If
2458 * there is no Vector component, total() returns the same value as
2459 * the first entry in the VResult val() returns.
2460 * @return The total of the result vector.
2461 */
2462 Result total() const;
2463
2464 /**
2465 * Return the number of elements in the tree.
2466 */
2467 size_type size() const;
2468
2469 void prepare() { }
2470
2471 /**
2472 * Formulas don't need to be reset
2473 */
2474 void reset();
2475
2476 /**
2477 *
2478 */
2479 bool zero() const;
2480
2481 std::string str() const;
2482};
2483
2484class FormulaNode : public Node
2485{
2486 private:
2487 const Formula &formula;
2488 mutable VResult vec;
2489
2490 public:
2491 FormulaNode(const Formula &f) : formula(f) {}
2492
2493 size_type size() const { return formula.size(); }
2494 const VResult &result() const { formula.result(vec); return vec; }
2495 Result total() const { return formula.total(); }
2496
2497 std::string str() const { return formula.str(); }
2498};
2499
2500/**
2501 * Helper class to construct formula node trees.
2502 */
2503class Temp
2504{
2505 protected:
2506 /**
2507 * Pointer to a Node object.
2508 */
2509 NodePtr node;
2510
2511 public:
2512 /**
2513 * Copy the given pointer to this class.
2514 * @param n A pointer to a Node object to copy.
2515 */
2516 Temp(NodePtr n) : node(n) { }
2517
2518 /**
2519 * Return the node pointer.
2520 * @return the node pointer.
2521 */
2522 operator NodePtr&() { return node; }
2523
2524 public:
2525 /**
2526 * Create a new ScalarStatNode.
2527 * @param s The ScalarStat to place in a node.
2528 */
2529 Temp(const Scalar &s)
2530 : node(new ScalarStatNode(s.info()))
2531 { }
2532
2533 /**
2534 * Create a new ScalarStatNode.
2535 * @param s The ScalarStat to place in a node.
2536 */
2537 Temp(const Value &s)
2538 : node(new ScalarStatNode(s.info()))
2539 { }
2540
2541 /**
2542 * Create a new ScalarStatNode.
2543 * @param s The ScalarStat to place in a node.
2544 */
2545 Temp(const Average &s)
2546 : node(new ScalarStatNode(s.info()))
2547 { }
2548
2549 /**
2550 * Create a new VectorStatNode.
2551 * @param s The VectorStat to place in a node.
2552 */
2553 Temp(const Vector &s)
2554 : node(new VectorStatNode(s.info()))
2555 { }
2556
|