statistics.hh (5582:c2fd66e6a919) statistics.hh (5598:345ef3bda3d2)
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;

--- 163 unchanged lines hidden (view full) ---

172 /** Names and descriptions of subfields. */
173 mutable std::vector<std::string> subnames;
174 mutable std::vector<std::string> subdescs;
175
176 virtual size_t size() const = 0;
177 virtual const VCounter &value() const = 0;
178 virtual const VResult &result() const = 0;
179 virtual Result total() const = 0;
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;

--- 163 unchanged lines hidden (view full) ---

172 /** Names and descriptions of subfields. */
173 mutable std::vector<std::string> subnames;
174 mutable std::vector<std::string> subdescs;
175
176 virtual size_t size() const = 0;
177 virtual const VCounter &value() const = 0;
178 virtual const VResult &result() const = 0;
179 virtual Result total() const = 0;
180 void update()
180
181 void
182 update()
181 {
182 if (!subnames.empty()) {
183 int s = size();
184 if (subnames.size() < s)
185 subnames.resize(s);
186
187 if (subdescs.size() < s)
188 subdescs.resize(s);

--- 12 unchanged lines hidden (view full) ---

201 public:
202 VectorStatData(Stat &stat) : s(stat) {}
203
204 virtual bool check() const { return s.check(); }
205 virtual bool zero() const { return s.zero(); }
206 virtual void reset() { s.reset(); }
207
208 virtual size_t size() const { return s.size(); }
183 {
184 if (!subnames.empty()) {
185 int s = size();
186 if (subnames.size() < s)
187 subnames.resize(s);
188
189 if (subdescs.size() < s)
190 subdescs.resize(s);

--- 12 unchanged lines hidden (view full) ---

203 public:
204 VectorStatData(Stat &stat) : s(stat) {}
205
206 virtual bool check() const { return s.check(); }
207 virtual bool zero() const { return s.zero(); }
208 virtual void reset() { s.reset(); }
209
210 virtual size_t size() const { return s.size(); }
209 virtual VCounter &value() const
211
212 virtual VCounter &
213 value() const
210 {
211 s.value(cvec);
212 return cvec;
213 }
214 {
215 s.value(cvec);
216 return cvec;
217 }
214 virtual const VResult &result() const
218
219 virtual const VResult &
220 result() const
215 {
216 s.result(rvec);
217 return rvec;
218 }
221 {
222 s.result(rvec);
223 return rvec;
224 }
225
219 virtual Result total() const { return s.total(); }
226 virtual Result total() const { return s.total(); }
220 virtual void visit(Visit &visitor)
227
228 virtual void
229 visit(Visit &visitor)
221 {
222 update();
223 s.update(this);
224 visitor.visit(*this);
225 }
226};
227
228struct DistDataData

--- 27 unchanged lines hidden (view full) ---

256 Stat &s;
257
258 public:
259 DistStatData(Stat &stat) : s(stat) {}
260
261 virtual bool check() const { return s.check(); }
262 virtual void reset() { s.reset(); }
263 virtual bool zero() const { return s.zero(); }
230 {
231 update();
232 s.update(this);
233 visitor.visit(*this);
234 }
235};
236
237struct DistDataData

--- 27 unchanged lines hidden (view full) ---

265 Stat &s;
266
267 public:
268 DistStatData(Stat &stat) : s(stat) {}
269
270 virtual bool check() const { return s.check(); }
271 virtual void reset() { s.reset(); }
272 virtual bool zero() const { return s.zero(); }
264 virtual void visit(Visit &visitor)
273
274 virtual void
275 visit(Visit &visitor)
265 {
266 s.update(this);
267 visitor.visit(*this);
268 }
269};
270
271struct VectorDistData : public StatData
272{
273 std::vector<DistDataData> data;
274
275 /** Names and descriptions of subfields. */
276 mutable std::vector<std::string> subnames;
277 mutable std::vector<std::string> subdescs;
278
279 /** Local storage for the entry values, used for printing. */
280 mutable VResult rvec;
281
282 virtual size_t size() const = 0;
276 {
277 s.update(this);
278 visitor.visit(*this);
279 }
280};
281
282struct VectorDistData : public StatData
283{
284 std::vector<DistDataData> data;
285
286 /** Names and descriptions of subfields. */
287 mutable std::vector<std::string> subnames;
288 mutable std::vector<std::string> subdescs;
289
290 /** Local storage for the entry values, used for printing. */
291 mutable VResult rvec;
292
293 virtual size_t size() const = 0;
283 void update()
294
295 void
296 update()
284 {
285 int s = size();
286 if (subnames.size() < s)
287 subnames.resize(s);
288
289 if (subdescs.size() < s)
290 subdescs.resize(s);
291 }

--- 7 unchanged lines hidden (view full) ---

299
300 public:
301 VectorDistStatData(Stat &stat) : s(stat) {}
302
303 virtual bool check() const { return s.check(); }
304 virtual void reset() { s.reset(); }
305 virtual size_t size() const { return s.size(); }
306 virtual bool zero() const { return s.zero(); }
297 {
298 int s = size();
299 if (subnames.size() < s)
300 subnames.resize(s);
301
302 if (subdescs.size() < s)
303 subdescs.resize(s);
304 }

--- 7 unchanged lines hidden (view full) ---

312
313 public:
314 VectorDistStatData(Stat &stat) : s(stat) {}
315
316 virtual bool check() const { return s.check(); }
317 virtual void reset() { s.reset(); }
318 virtual size_t size() const { return s.size(); }
319 virtual bool zero() const { return s.zero(); }
307 virtual void visit(Visit &visitor)
320
321 virtual void
322 visit(Visit &visitor)
308 {
309 update();
310 s.update(this);
311 visitor.visit(*this);
312 }
313};
314
315struct Vector2dData : public StatData
316{
317 /** Names and descriptions of subfields. */
318 std::vector<std::string> subnames;
319 std::vector<std::string> subdescs;
320 std::vector<std::string> y_subnames;
321
322 /** Local storage for the entry values, used for printing. */
323 mutable VCounter cvec;
324 mutable int x;
325 mutable int y;
326
323 {
324 update();
325 s.update(this);
326 visitor.visit(*this);
327 }
328};
329
330struct Vector2dData : public StatData
331{
332 /** Names and descriptions of subfields. */
333 std::vector<std::string> subnames;
334 std::vector<std::string> subdescs;
335 std::vector<std::string> y_subnames;
336
337 /** Local storage for the entry values, used for printing. */
338 mutable VCounter cvec;
339 mutable int x;
340 mutable int y;
341
327 void update()
342 void
343 update()
328 {
329 if (subnames.size() < x)
330 subnames.resize(x);
331 }
332};
333
334template <class Stat>
335class Vector2dStatData : public Vector2dData
336{
337 protected:
338 Stat &s;
339
340 public:
341 Vector2dStatData(Stat &stat) : s(stat) {}
342
343 virtual bool check() const { return s.check(); }
344 virtual void reset() { s.reset(); }
345 virtual bool zero() const { return s.zero(); }
344 {
345 if (subnames.size() < x)
346 subnames.resize(x);
347 }
348};
349
350template <class Stat>
351class Vector2dStatData : public Vector2dData
352{
353 protected:
354 Stat &s;
355
356 public:
357 Vector2dStatData(Stat &stat) : s(stat) {}
358
359 virtual bool check() const { return s.check(); }
360 virtual void reset() { s.reset(); }
361 virtual bool zero() const { return s.zero(); }
346 virtual void visit(Visit &visitor)
362
363 virtual void
364 visit(Visit &visitor)
347 {
348 update();
349 s.update(this);
350 visitor.visit(*this);
351 }
352};
353
354class DataAccess

--- 11 unchanged lines hidden (view full) ---

366
367template <class Parent, class Child, template <class> class Data>
368class Wrap : public Child
369{
370 protected:
371 Parent &self() { return *reinterpret_cast<Parent *>(this); }
372
373 protected:
365 {
366 update();
367 s.update(this);
368 visitor.visit(*this);
369 }
370};
371
372class DataAccess

--- 11 unchanged lines hidden (view full) ---

384
385template <class Parent, class Child, template <class> class Data>
386class Wrap : public Child
387{
388 protected:
389 Parent &self() { return *reinterpret_cast<Parent *>(this); }
390
391 protected:
374 Data<Child> *statData()
392 Data *
393 statData()
375 {
376 StatData *__data = DataAccess::statData();
377 Data<Child> *ptr = dynamic_cast<Data<Child> *>(__data);
378 assert(ptr);
379 return ptr;
380 }
381
382 public:
394 {
395 StatData *__data = DataAccess::statData();
396 Data<Child> *ptr = dynamic_cast<Data<Child> *>(__data);
397 assert(ptr);
398 return ptr;
399 }
400
401 public:
383 const Data<Child> *statData() const
402 const Data *
403 statData() const
384 {
385 const StatData *__data = DataAccess::statData();
386 const Data<Child> *ptr = dynamic_cast<const Data<Child> *>(__data);
387 assert(ptr);
388 return ptr;
389 }
390
391 protected:
392 /**
393 * Copy constructor, copies are not allowed.
394 */
395 Wrap(const Wrap &stat);
404 {
405 const StatData *__data = DataAccess::statData();
406 const Data<Child> *ptr = dynamic_cast<const Data<Child> *>(__data);
407 assert(ptr);
408 return ptr;
409 }
410
411 protected:
412 /**
413 * Copy constructor, copies are not allowed.
414 */
415 Wrap(const Wrap &stat);
416
396 /**
397 * Can't copy stats.
398 */
399 void operator=(const Wrap &);
400
401 public:
402 Wrap()
403 {
404 this->map(new Data<Child>(*this));
405 }
406
407 /**
408 * Set the name and marks this stat to print at the end of simulation.
409 * @param name The new name.
410 * @return A reference to this stat.
411 */
417 /**
418 * Can't copy stats.
419 */
420 void operator=(const Wrap &);
421
422 public:
423 Wrap()
424 {
425 this->map(new Data<Child>(*this));
426 }
427
428 /**
429 * Set the name and marks this stat to print at the end of simulation.
430 * @param name The new name.
431 * @return A reference to this stat.
432 */
412 Parent &name(const std::string &_name)
433 Parent &
434 name(const std::string &_name)
413 {
414 Data<Child> *data = this->statData();
415 data->name = _name;
416 this->setPrint();
417 return this->self();
418 }
419
420 /**
421 * Set the description and marks this stat to print at the end of
422 * simulation.
423 * @param desc The new description.
424 * @return A reference to this stat.
425 */
435 {
436 Data<Child> *data = this->statData();
437 data->name = _name;
438 this->setPrint();
439 return this->self();
440 }
441
442 /**
443 * Set the description and marks this stat to print at the end of
444 * simulation.
445 * @param desc The new description.
446 * @return A reference to this stat.
447 */
426 Parent &desc(const std::string &_desc)
448 Parent &
449 desc(const std::string &_desc)
427 {
428 this->statData()->desc = _desc;
429 return this->self();
430 }
431
432 /**
433 * Set the precision and marks this stat to print at the end of simulation.
434 * @param p The new precision
435 * @return A reference to this stat.
436 */
450 {
451 this->statData()->desc = _desc;
452 return this->self();
453 }
454
455 /**
456 * Set the precision and marks this stat to print at the end of simulation.
457 * @param p The new precision
458 * @return A reference to this stat.
459 */
437 Parent &precision(int _precision)
460 Parent &
461 precision(int _precision)
438 {
439 this->statData()->precision = _precision;
440 return this->self();
441 }
442
443 /**
444 * Set the flags and marks this stat to print at the end of simulation.
445 * @param f The new flags.
446 * @return A reference to this stat.
447 */
462 {
463 this->statData()->precision = _precision;
464 return this->self();
465 }
466
467 /**
468 * Set the flags and marks this stat to print at the end of simulation.
469 * @param f The new flags.
470 * @return A reference to this stat.
471 */
448 Parent &flags(StatFlags _flags)
472 Parent &
473 flags(StatFlags _flags)
449 {
450 this->statData()->flags |= _flags;
451 return this->self();
452 }
453
454 /**
455 * Set the prerequisite stat and marks this stat to print at the end of
456 * simulation.
457 * @param prereq The prerequisite stat.
458 * @return A reference to this stat.
459 */
460 template <class Stat>
474 {
475 this->statData()->flags |= _flags;
476 return this->self();
477 }
478
479 /**
480 * Set the prerequisite stat and marks this stat to print at the end of
481 * simulation.
482 * @param prereq The prerequisite stat.
483 * @return A reference to this stat.
484 */
485 template <class Stat>
461 Parent &prereq(const Stat &prereq)
486 Parent &
487 prereq(const Stat &prereq)
462 {
463 this->statData()->prereq = prereq.statData();
464 return this->self();
465 }
466};
467
468template <class Parent, class Child, template <class Child> class Data>
469class WrapVec : public Wrap<Parent, Child, Data>

--- 4 unchanged lines hidden (view full) ---

474
475 /**
476 * Set the subfield name for the given index, and marks this stat to print
477 * at the end of simulation.
478 * @param index The subfield index.
479 * @param name The new name of the subfield.
480 * @return A reference to this stat.
481 */
488 {
489 this->statData()->prereq = prereq.statData();
490 return this->self();
491 }
492};
493
494template <class Parent, class Child, template <class Child> class Data>
495class WrapVec : public Wrap<Parent, Child, Data>

--- 4 unchanged lines hidden (view full) ---

500
501 /**
502 * Set the subfield name for the given index, and marks this stat to print
503 * at the end of simulation.
504 * @param index The subfield index.
505 * @param name The new name of the subfield.
506 * @return A reference to this stat.
507 */
482 Parent &subname(int index, const std::string &name)
508 Parent &
509 subname(int index, const std::string &name)
483 {
484 std::vector<std::string> &subn = this->statData()->subnames;
485 if (subn.size() <= index)
486 subn.resize(index + 1);
487 subn[index] = name;
488 return this->self();
489 }
490
491 /**
492 * Set the subfield description for the given index and marks this stat to
493 * print at the end of simulation.
494 * @param index The subfield index.
495 * @param desc The new description of the subfield
496 * @return A reference to this stat.
497 */
510 {
511 std::vector<std::string> &subn = this->statData()->subnames;
512 if (subn.size() <= index)
513 subn.resize(index + 1);
514 subn[index] = name;
515 return this->self();
516 }
517
518 /**
519 * Set the subfield description for the given index and marks this stat to
520 * print at the end of simulation.
521 * @param index The subfield index.
522 * @param desc The new description of the subfield
523 * @return A reference to this stat.
524 */
498 Parent &subdesc(int index, const std::string &desc)
525 Parent &
526 subdesc(int index, const std::string &desc)
499 {
500 std::vector<std::string> &subd = this->statData()->subdescs;
501 if (subd.size() <= index)
502 subd.resize(index + 1);
503 subd[index] = desc;
504
505 return this->self();
506 }
507
508};
509
510template <class Parent, class Child, template <class Child> class Data>
511class WrapVec2d : public WrapVec<Parent, Child, Data>
512{
513 public:
514 /**
515 * @warning This makes the assumption that if you're gonna subnames a 2d
516 * vector, you're subnaming across all y
517 */
527 {
528 std::vector<std::string> &subd = this->statData()->subdescs;
529 if (subd.size() <= index)
530 subd.resize(index + 1);
531 subd[index] = desc;
532
533 return this->self();
534 }
535
536};
537
538template <class Parent, class Child, template <class Child> class Data>
539class WrapVec2d : public WrapVec<Parent, Child, Data>
540{
541 public:
542 /**
543 * @warning This makes the assumption that if you're gonna subnames a 2d
544 * vector, you're subnaming across all y
545 */
518 Parent &ysubnames(const char **names)
546 Parent &
547 ysubnames(const char **names)
519 {
520 Data<Child> *data = this->statData();
521 data->y_subnames.resize(this->y);
522 for (int i = 0; i < this->y; ++i)
523 data->y_subnames[i] = names[i];
524 return this->self();
525 }
548 {
549 Data<Child> *data = this->statData();
550 data->y_subnames.resize(this->y);
551 for (int i = 0; i < this->y; ++i)
552 data->y_subnames[i] = names[i];
553 return this->self();
554 }
526 Parent &ysubname(int index, const std::string subname)
555
556 Parent &
557 ysubname(int index, const std::string subname)
527 {
528 Data<Child> *data = this->statData();
529 assert(index < this->y);
530 data->y_subnames.resize(this->y);
531 data->y_subnames[index] = subname.c_str();
532 return this->self();
533 }
534};

--- 93 unchanged lines hidden (view full) ---

628 AvgStor(Params &p) : current(0), total(0), last(0) { }
629
630 /**
631 * Set the current count to the one provided, update the total and last
632 * set values.
633 * @param val The new count.
634 * @param p The parameters for this storage.
635 */
558 {
559 Data<Child> *data = this->statData();
560 assert(index < this->y);
561 data->y_subnames.resize(this->y);
562 data->y_subnames[index] = subname.c_str();
563 return this->self();
564 }
565};

--- 93 unchanged lines hidden (view full) ---

659 AvgStor(Params &p) : current(0), total(0), last(0) { }
660
661 /**
662 * Set the current count to the one provided, update the total and last
663 * set values.
664 * @param val The new count.
665 * @param p The parameters for this storage.
666 */
636 void set(Counter val, Params &p) {
667 void
668 set(Counter val, Params &p) {
637 total += current * (curTick - last);
638 last = curTick;
639 current = val;
640 }
641
642 /**
643 * Increment the current count by the provided value, calls set.
644 * @param val The amount to increment.

--- 15 unchanged lines hidden (view full) ---

660 */
661 Counter value(const Params &p) const { return current; }
662
663 /**
664 * Return the current average.
665 * @param p The parameters for this storage.
666 * @return The current average.
667 */
669 total += current * (curTick - last);
670 last = curTick;
671 current = val;
672 }
673
674 /**
675 * Increment the current count by the provided value, calls set.
676 * @param val The amount to increment.

--- 15 unchanged lines hidden (view full) ---

692 */
693 Counter value(const Params &p) const { return current; }
694
695 /**
696 * Return the current average.
697 * @param p The parameters for this storage.
698 * @return The current average.
699 */
668 Result result(const Params &p) const
700 Result
701 result(const Params &p) const
669 {
670 total += current * (curTick - last);
671 last = curTick;
672 return (Result)(total + current) / (Result)(curTick + 1);
673 }
674
675 /**
676 * Reset stat value to default
677 */
702 {
703 total += current * (curTick - last);
704 last = curTick;
705 return (Result)(total + current) / (Result)(curTick + 1);
706 }
707
708 /**
709 * Reset stat value to default
710 */
678 void reset()
711 void
712 reset()
679 {
680 total = 0;
681 last = curTick;
682 }
683
684 /**
685 * @return true if zero value
686 */

--- 172 unchanged lines hidden (view full) ---

859 private:
860 ProxyData *proxy;
861
862 public:
863 ValueBase() : proxy(NULL) { }
864 ~ValueBase() { if (proxy) delete proxy; }
865
866 template <class T>
713 {
714 total = 0;
715 last = curTick;
716 }
717
718 /**
719 * @return true if zero value
720 */

--- 172 unchanged lines hidden (view full) ---

893 private:
894 ProxyData *proxy;
895
896 public:
897 ValueBase() : proxy(NULL) { }
898 ~ValueBase() { if (proxy) delete proxy; }
899
900 template <class T>
867 void scalar(T &value)
901 void
902 scalar(T &value)
868 {
869 proxy = new ValueProxy<T>(value);
870 setInit();
871 }
872
873 template <class T>
903 {
904 proxy = new ValueProxy<T>(value);
905 setInit();
906 }
907
908 template <class T>
874 void functor(T &func)
909 void
910 functor(T &func)
875 {
876 proxy = new FunctorProxy<T>(func);
877 setInit();
878 }
879
880 Counter value() { return proxy->value(); }
881 Result result() const { return proxy->result(); }
882 Result total() const { return proxy->total(); };

--- 58 unchanged lines hidden (view full) ---

941 : stat(sp.stat), index(sp.index)
942 {}
943
944 /**
945 * Set this proxy equal to the provided one.
946 * @param sp The proxy to copy.
947 * @return A reference to this proxy.
948 */
911 {
912 proxy = new FunctorProxy<T>(func);
913 setInit();
914 }
915
916 Counter value() { return proxy->value(); }
917 Result result() const { return proxy->result(); }
918 Result total() const { return proxy->total(); };

--- 58 unchanged lines hidden (view full) ---

977 : stat(sp.stat), index(sp.index)
978 {}
979
980 /**
981 * Set this proxy equal to the provided one.
982 * @param sp The proxy to copy.
983 * @return A reference to this proxy.
984 */
949 const ScalarProxy &operator=(const ScalarProxy &sp) {
985 const ScalarProxy &
986 operator=(const ScalarProxy &sp) {
950 stat = sp.stat;
951 index = sp.index;
952 return *this;
953 }
954
955 public:
956 // Common operators for stats
957 /**

--- 13 unchanged lines hidden (view full) ---

971 void operator--(int) { --*this; }
972
973 /**
974 * Set the data value to the given value. This calls the associated storage
975 * object set function.
976 * @param v The new value.
977 */
978 template <typename U>
987 stat = sp.stat;
988 index = sp.index;
989 return *this;
990 }
991
992 public:
993 // Common operators for stats
994 /**

--- 13 unchanged lines hidden (view full) ---

1008 void operator--(int) { --*this; }
1009
1010 /**
1011 * Set the data value to the given value. This calls the associated storage
1012 * object set function.
1013 * @param v The new value.
1014 */
1015 template <typename U>
979 void operator=(const U &v) { stat->data(index)->set(v, stat->params); }
1016 void
1017 operator=(const U &v)
1018 {
1019 stat->data(index)->set(v, stat->params);
1020 }
980
981 /**
982 * Increment the stat by the given value. This calls the associated
983 * storage object inc function.
984 * @param v The value to add.
985 */
986 template <typename U>
1021
1022 /**
1023 * Increment the stat by the given value. This calls the associated
1024 * storage object inc function.
1025 * @param v The value to add.
1026 */
1027 template <typename U>
987 void operator+=(const U &v) { stat->data(index)->inc(v, stat->params); }
1028 void
1029 operator+=(const U &v)
1030 {
1031 stat->data(index)->inc(v, stat->params);
1032 }
988
989 /**
990 * Decrement the stat by the given value. This calls the associated
991 * storage object dec function.
992 * @param v The value to substract.
993 */
994 template <typename U>
1033
1034 /**
1035 * Decrement the stat by the given value. This calls the associated
1036 * storage object dec function.
1037 * @param v The value to substract.
1038 */
1039 template <typename U>
995 void operator-=(const U &v) { stat->data(index)->dec(v, stat->params); }
1040 void
1041 operator-=(const U &v)
1042 {
1043 stat->data(index)->dec(v, stat->params);
1044 }
996
997 /**
998 * Return the number of elements, always 1 for a scalar.
999 * @return 1.
1000 */
1001 size_t size() const { return 1; }
1002
1003 /**

--- 62 unchanged lines hidden (view full) ---

1066
1067 for (int i = 0; i < _size; ++i)
1068 new (&storage[i]) Storage(params);
1069
1070 setInit();
1071 }
1072
1073 public:
1045
1046 /**
1047 * Return the number of elements, always 1 for a scalar.
1048 * @return 1.
1049 */
1050 size_t size() const { return 1; }
1051
1052 /**

--- 62 unchanged lines hidden (view full) ---

1115
1116 for (int i = 0; i < _size; ++i)
1117 new (&storage[i]) Storage(params);
1118
1119 setInit();
1120 }
1121
1122 public:
1074 void value(VCounter &vec) const
1123 void
1124 value(VCounter &vec) const
1075 {
1076 vec.resize(size());
1077 for (int i = 0; i < size(); ++i)
1078 vec[i] = data(i)->value(params);
1079 }
1080
1081 /**
1082 * Copy the values to a local vector and return a reference to it.
1083 * @return A reference to a vector of the stat values.
1084 */
1125 {
1126 vec.resize(size());
1127 for (int i = 0; i < size(); ++i)
1128 vec[i] = data(i)->value(params);
1129 }
1130
1131 /**
1132 * Copy the values to a local vector and return a reference to it.
1133 * @return A reference to a vector of the stat values.
1134 */
1085 void result(VResult &vec) const
1135 void
1136 result(VResult &vec) const
1086 {
1087 vec.resize(size());
1088 for (int i = 0; i < size(); ++i)
1089 vec[i] = data(i)->result(params);
1090 }
1091
1092 /**
1093 * Return a total of all entries in this vector.
1094 * @return The total of all vector entries.
1095 */
1137 {
1138 vec.resize(size());
1139 for (int i = 0; i < size(); ++i)
1140 vec[i] = data(i)->result(params);
1141 }
1142
1143 /**
1144 * Return a total of all entries in this vector.
1145 * @return The total of all vector entries.
1146 */
1096 Result total() const {
1147 Result
1148 total() const
1149 {
1097 Result total = 0.0;
1098 for (int i = 0; i < size(); ++i)
1099 total += data(i)->result(params);
1100 return total;
1101 }
1102
1103 /**
1104 * @return the number of elements in this vector.

--- 113 unchanged lines hidden (view full) ---

1218 operator=(const VectorProxy &sp)
1219 {
1220 stat = sp.stat;
1221 offset = sp.offset;
1222 len = sp.len;
1223 return *this;
1224 }
1225
1150 Result total = 0.0;
1151 for (int i = 0; i < size(); ++i)
1152 total += data(i)->result(params);
1153 return total;
1154 }
1155
1156 /**
1157 * @return the number of elements in this vector.

--- 113 unchanged lines hidden (view full) ---

1271 operator=(const VectorProxy &sp)
1272 {
1273 stat = sp.stat;
1274 offset = sp.offset;
1275 len = sp.len;
1276 return *this;
1277 }
1278
1226 ScalarProxy<Stat> operator[](int index)
1279 ScalarProxy
1280 operator[](int index)
1227 {
1228 assert (index >= 0 && index < size());
1229 return ScalarProxy<Stat>(stat, offset + index);
1230 }
1231
1232 size_t size() const { return len; }
1233
1234 /**

--- 168 unchanged lines hidden (view full) ---

1403 }
1404
1405 /**
1406 * Add a value to the distribution for the given number of times.
1407 * @param val The value to add.
1408 * @param number The number of times to add the value.
1409 * @param params The paramters of the distribution.
1410 */
1281 {
1282 assert (index >= 0 && index < size());
1283 return ScalarProxy<Stat>(stat, offset + index);
1284 }
1285
1286 size_t size() const { return len; }
1287
1288 /**

--- 168 unchanged lines hidden (view full) ---

1457 }
1458
1459 /**
1460 * Add a value to the distribution for the given number of times.
1461 * @param val The value to add.
1462 * @param number The number of times to add the value.
1463 * @param params The paramters of the distribution.
1464 */
1411 void sample(Counter val, int number, const Params &params)
1465 void
1466 sample(Counter val, int number, const Params &params)
1412 {
1413 if (val < params.min)
1414 underflow += number;
1415 else if (val > params.max)
1416 overflow += number;
1417 else {
1467 {
1468 if (val < params.min)
1469 underflow += number;
1470 else if (val > params.max)
1471 overflow += number;
1472 else {
1418 int index = (int)std::floor((val - params.min) / params.bucket_size);
1473 size_t index = std::floor((val - params.min) / params.bucket_size);
1419 assert(index < size(params));
1420 cvec[index] += number;
1421 }
1422
1423 if (val < min_val)
1424 min_val = val;
1425
1426 if (val > max_val)

--- 12 unchanged lines hidden (view full) ---

1439 */
1440 size_t size(const Params &) const { return cvec.size(); }
1441
1442 /**
1443 * Returns true if any calls to sample have been made.
1444 * @param params The paramters of the distribution.
1445 * @return True if any values have been sampled.
1446 */
1474 assert(index < size(params));
1475 cvec[index] += number;
1476 }
1477
1478 if (val < min_val)
1479 min_val = val;
1480
1481 if (val > max_val)

--- 12 unchanged lines hidden (view full) ---

1494 */
1495 size_t size(const Params &) const { return cvec.size(); }
1496
1497 /**
1498 * Returns true if any calls to sample have been made.
1499 * @param params The paramters of the distribution.
1500 * @return True if any values have been sampled.
1501 */
1447 bool zero(const Params &params) const
1502 bool
1503 zero(const Params &params) const
1448 {
1449 return samples == Counter();
1450 }
1451
1504 {
1505 return samples == Counter();
1506 }
1507
1452 void update(DistDataData *data, const Params &params)
1508 void
1509 update(DistDataData *data, const Params &params)
1453 {
1454 data->min = params.min;
1455 data->max = params.max;
1456 data->bucket_size = params.bucket_size;
1457 data->size = params.size;
1458
1459 data->min_val = (min_val == CounterLimits::max()) ? 0 : min_val;
1460 data->max_val = (max_val == CounterLimits::min()) ? 0 : max_val;

--- 6 unchanged lines hidden (view full) ---

1467 data->sum = sum;
1468 data->squares = squares;
1469 data->samples = samples;
1470 }
1471
1472 /**
1473 * Reset stat value to default
1474 */
1510 {
1511 data->min = params.min;
1512 data->max = params.max;
1513 data->bucket_size = params.bucket_size;
1514 data->size = params.size;
1515
1516 data->min_val = (min_val == CounterLimits::max()) ? 0 : min_val;
1517 data->max_val = (max_val == CounterLimits::min()) ? 0 : max_val;

--- 6 unchanged lines hidden (view full) ---

1524 data->sum = sum;
1525 data->squares = squares;
1526 data->samples = samples;
1527 }
1528
1529 /**
1530 * Reset stat value to default
1531 */
1475 void reset()
1532 void
1533 reset()
1476 {
1477 min_val = CounterLimits::max();
1478 max_val = CounterLimits::min();
1479 underflow = 0;
1480 overflow = 0;
1481
1482 int size = cvec.size();
1483 for (int i = 0; i < size; ++i)

--- 37 unchanged lines hidden (view full) ---

1521 /**
1522 * Add a value the given number of times to this running average.
1523 * Update the running sum and sum of squares, increment the number of
1524 * values seen by the given number.
1525 * @param val The value to add.
1526 * @param number The number of times to add the value.
1527 * @param p The parameters of this stat.
1528 */
1534 {
1535 min_val = CounterLimits::max();
1536 max_val = CounterLimits::min();
1537 underflow = 0;
1538 overflow = 0;
1539
1540 int size = cvec.size();
1541 for (int i = 0; i < size; ++i)

--- 37 unchanged lines hidden (view full) ---

1579 /**
1580 * Add a value the given number of times to this running average.
1581 * Update the running sum and sum of squares, increment the number of
1582 * values seen by the given number.
1583 * @param val The value to add.
1584 * @param number The number of times to add the value.
1585 * @param p The parameters of this stat.
1586 */
1529 void sample(Counter val, int number, const Params &p)
1587 void
1588 sample(Counter val, int number, const Params &p)
1530 {
1531 Counter value = val * number;
1532 sum += value;
1533 squares += value * value;
1534 samples += number;
1535 }
1536
1589 {
1590 Counter value = val * number;
1591 sum += value;
1592 squares += value * value;
1593 samples += number;
1594 }
1595
1537 void update(DistDataData *data, const Params &params)
1596 void
1597 update(DistDataData *data, const Params &params)
1538 {
1539 data->sum = sum;
1540 data->squares = squares;
1541 data->samples = samples;
1542 }
1543
1544 /**
1545 * Return the number of entries in this stat, 1

--- 5 unchanged lines hidden (view full) ---

1551 * Return true if no samples have been added.
1552 * @return True if no samples have been added.
1553 */
1554 bool zero(const Params &) const { return samples == Counter(); }
1555
1556 /**
1557 * Reset stat value to default
1558 */
1598 {
1599 data->sum = sum;
1600 data->squares = squares;
1601 data->samples = samples;
1602 }
1603
1604 /**
1605 * Return the number of entries in this stat, 1

--- 5 unchanged lines hidden (view full) ---

1611 * Return true if no samples have been added.
1612 * @return True if no samples have been added.
1613 */
1614 bool zero(const Params &) const { return samples == Counter(); }
1615
1616 /**
1617 * Reset stat value to default
1618 */
1559 void reset()
1619 void
1620 reset()
1560 {
1561 sum = Counter();
1562 squares = Counter();
1563 samples = Counter();
1564 }
1565};
1566
1567/**

--- 21 unchanged lines hidden (view full) ---

1589
1590 /**
1591 * Add a value to the distribution for the given number of times.
1592 * Update the running sum and sum of squares.
1593 * @param val The value to add.
1594 * @param number The number of times to add the value.
1595 * @param p The paramters of the distribution.
1596 */
1621 {
1622 sum = Counter();
1623 squares = Counter();
1624 samples = Counter();
1625 }
1626};
1627
1628/**

--- 21 unchanged lines hidden (view full) ---

1650
1651 /**
1652 * Add a value to the distribution for the given number of times.
1653 * Update the running sum and sum of squares.
1654 * @param val The value to add.
1655 * @param number The number of times to add the value.
1656 * @param p The paramters of the distribution.
1657 */
1597 void sample(Counter val, int number, const Params &p)
1658 void
1659 sample(Counter val, int number, const Params &p)
1598 {
1599 Counter value = val * number;
1600 sum += value;
1601 squares += value * value;
1602 }
1603
1660 {
1661 Counter value = val * number;
1662 sum += value;
1663 squares += value * value;
1664 }
1665
1604 void update(DistDataData *data, const Params &params)
1666 void
1667 update(DistDataData *data, const Params &params)
1605 {
1606 data->sum = sum;
1607 data->squares = squares;
1608 data->samples = curTick;
1609 }
1610
1611 /**
1612 * Return the number of entries, in this case 1.
1613 * @return 1.
1614 */
1615 size_t size(const Params &params) const { return 1; }
1668 {
1669 data->sum = sum;
1670 data->squares = squares;
1671 data->samples = curTick;
1672 }
1673
1674 /**
1675 * Return the number of entries, in this case 1.
1676 * @return 1.
1677 */
1678 size_t size(const Params &params) const { return 1; }
1679
1616 /**
1617 * Return true if no samples have been added.
1618 * @return True if the sum is zero.
1619 */
1620 bool zero(const Params &params) const { return sum == Counter(); }
1680 /**
1681 * Return true if no samples have been added.
1682 * @return True if the sum is zero.
1683 */
1684 bool zero(const Params &params) const { return sum == Counter(); }
1685
1621 /**
1622 * Reset stat value to default
1623 */
1686 /**
1687 * Reset stat value to default
1688 */
1624 void reset()
1689 void
1690 reset()
1625 {
1626 sum = Counter();
1627 squares = Counter();
1628 }
1629};
1630
1631/**
1632 * Implementation of a distribution stat. The type of distribution is

--- 14 unchanged lines hidden (view full) ---

1647 /** The parameters for this stat. */
1648 Params params;
1649
1650 protected:
1651 /**
1652 * Retrieve the storage.
1653 * @return The storage object for this stat.
1654 */
1691 {
1692 sum = Counter();
1693 squares = Counter();
1694 }
1695};
1696
1697/**
1698 * Implementation of a distribution stat. The type of distribution is

--- 14 unchanged lines hidden (view full) ---

1713 /** The parameters for this stat. */
1714 Params params;
1715
1716 protected:
1717 /**
1718 * Retrieve the storage.
1719 * @return The storage object for this stat.
1720 */
1655 Storage *data()
1721 Storage *
1722 data()
1656 {
1657 return reinterpret_cast<Storage *>(storage);
1658 }
1659
1660 /**
1661 * Retrieve a const pointer to the storage.
1662 * @return A const pointer to the storage object for this stat.
1663 */

--- 28 unchanged lines hidden (view full) ---

1692 */
1693 size_t size() const { return data()->size(params); }
1694 /**
1695 * Return true if no samples have been added.
1696 * @return True if there haven't been any samples.
1697 */
1698 bool zero() const { return data()->zero(params); }
1699
1723 {
1724 return reinterpret_cast<Storage *>(storage);
1725 }
1726
1727 /**
1728 * Retrieve a const pointer to the storage.
1729 * @return A const pointer to the storage object for this stat.
1730 */

--- 28 unchanged lines hidden (view full) ---

1759 */
1760 size_t size() const { return data()->size(params); }
1761 /**
1762 * Return true if no samples have been added.
1763 * @return True if there haven't been any samples.
1764 */
1765 bool zero() const { return data()->zero(params); }
1766
1700 void update(DistData *base)
1767 void
1768 update(DistData *base)
1701 {
1702 base->data.fancy = Storage::fancy;
1703 data()->update(&(base->data), params);
1704 }
1705
1706 /**
1707 * Reset stat value to default
1708 */

--- 134 unchanged lines hidden (view full) ---

1843 DistProxy(Stat *s, int i)
1844 : stat(s), index(i)
1845 {}
1846
1847 DistProxy(const DistProxy &sp)
1848 : stat(sp.stat), index(sp.index)
1849 {}
1850
1769 {
1770 base->data.fancy = Storage::fancy;
1771 data()->update(&(base->data), params);
1772 }
1773
1774 /**
1775 * Reset stat value to default
1776 */

--- 134 unchanged lines hidden (view full) ---

1911 DistProxy(Stat *s, int i)
1912 : stat(s), index(i)
1913 {}
1914
1915 DistProxy(const DistProxy &sp)
1916 : stat(sp.stat), index(sp.index)
1917 {}
1918
1851 const DistProxy &operator=(const DistProxy &sp)
1919 const DistProxy &
1920 operator=(const DistProxy &sp)
1852 {
1853 stat = sp.stat;
1854 index = sp.index;
1855 return *this;
1856 }
1857
1858 public:
1859 template <typename U>

--- 30 unchanged lines hidden (view full) ---

1890}
1891
1892#if 0
1893template <class Storage>
1894Result
1895VectorDistBase<Storage>::total(int index) const
1896{
1897 int total = 0;
1921 {
1922 stat = sp.stat;
1923 index = sp.index;
1924 return *this;
1925 }
1926
1927 public:
1928 template <typename U>

--- 30 unchanged lines hidden (view full) ---

1959}
1960
1961#if 0
1962template <class Storage>
1963Result
1964VectorDistBase<Storage>::total(int index) const
1965{
1966 int total = 0;
1898 for (int i = 0; i < x_size(); ++i) {
1967 for (int i = 0; i < x_size(); ++i)
1899 total += data(i)->result(stat->params);
1968 total += data(i)->result(stat->params);
1900 }
1901}
1902#endif
1903
1904//////////////////////////////////////////////////////////////////////
1905//
1906// Formula Details
1907//
1908//////////////////////////////////////////////////////////////////////

--- 33 unchanged lines hidden (view full) ---

1942class ScalarStatNode : public Node
1943{
1944 private:
1945 const ScalarData *data;
1946 mutable VResult vresult;
1947
1948 public:
1949 ScalarStatNode(const ScalarData *d) : data(d), vresult(1) {}
1969}
1970#endif
1971
1972//////////////////////////////////////////////////////////////////////
1973//
1974// Formula Details
1975//
1976//////////////////////////////////////////////////////////////////////

--- 33 unchanged lines hidden (view full) ---

2010class ScalarStatNode : public Node
2011{
2012 private:
2013 const ScalarData *data;
2014 mutable VResult vresult;
2015
2016 public:
2017 ScalarStatNode(const ScalarData *d) : data(d), vresult(1) {}
1950 virtual const VResult &result() const
2018
2019 virtual const VResult &
2020 result() const
1951 {
1952 vresult[0] = data->result();
1953 return vresult;
1954 }
2021 {
2022 vresult[0] = data->result();
2023 return vresult;
2024 }
2025
1955 virtual Result total() const { return data->result(); };
1956
1957 virtual size_t size() const { return 1; }
1958
1959 /**
1960 *
1961 */
1962 virtual std::string str() const { return data->name; }

--- 73 unchanged lines hidden (view full) ---

2036class ConstVectorNode : public Node
2037{
2038 private:
2039 VResult vresult;
2040
2041 public:
2042 ConstVectorNode(const T &s) : vresult(s.begin(), s.end()) {}
2043 const VResult &result() const { return vresult; }
2026 virtual Result total() const { return data->result(); };
2027
2028 virtual size_t size() const { return 1; }
2029
2030 /**
2031 *
2032 */
2033 virtual std::string str() const { return data->name; }

--- 73 unchanged lines hidden (view full) ---

2107class ConstVectorNode : public Node
2108{
2109 private:
2110 VResult vresult;
2111
2112 public:
2113 ConstVectorNode(const T &s) : vresult(s.begin(), s.end()) {}
2114 const VResult &result() const { return vresult; }
2044 virtual Result total() const
2115
2116 virtual Result
2117 total() const
2045 {
2046 int size = this->size();
2047 Result tmp = 0;
2048 for (int i = 0; i < size; i++)
2118 {
2119 int size = this->size();
2120 Result tmp = 0;
2121 for (int i = 0; i < size; i++)
2049 {
2050 tmp += vresult[i];
2122 tmp += vresult[i];
2051 }
2052 return tmp;
2053 }
2123 return tmp;
2124 }
2125
2054 virtual size_t size() const { return vresult.size(); }
2126 virtual size_t size() const { return vresult.size(); }
2055 virtual std::string str() const
2127 virtual std::string
2128 str() const
2056 {
2057 int size = this->size();
2058 std::string tmp = "(";
2059 for (int i = 0; i < size; i++)
2129 {
2130 int size = this->size();
2131 std::string tmp = "(";
2132 for (int i = 0; i < size; i++)
2060 {
2061 tmp += csprintf("%s ",to_string(vresult[i]));
2133 tmp += csprintf("%s ",to_string(vresult[i]));
2062 }
2063 tmp += ")";
2064 return tmp;
2065 }
2066};
2067
2068template <class Op>
2069struct OpString;
2070

--- 38 unchanged lines hidden (view full) ---

2109{
2110 public:
2111 NodePtr l;
2112 mutable VResult vresult;
2113
2114 public:
2115 UnaryNode(NodePtr &p) : l(p) {}
2116
2134 tmp += ")";
2135 return tmp;
2136 }
2137};
2138
2139template <class Op>
2140struct OpString;
2141

--- 38 unchanged lines hidden (view full) ---

2180{
2181 public:
2182 NodePtr l;
2183 mutable VResult vresult;
2184
2185 public:
2186 UnaryNode(NodePtr &p) : l(p) {}
2187
2117 const VResult &result() const
2188 const VResult &
2189 result() const
2118 {
2119 const VResult &lvec = l->result();
2120 int size = lvec.size();
2121
2122 assert(size > 0);
2123
2124 vresult.resize(size);
2125 Op op;
2126 for (int i = 0; i < size; ++i)
2127 vresult[i] = op(lvec[i]);
2128
2129 return vresult;
2130 }
2131
2190 {
2191 const VResult &lvec = l->result();
2192 int size = lvec.size();
2193
2194 assert(size > 0);
2195
2196 vresult.resize(size);
2197 Op op;
2198 for (int i = 0; i < size; ++i)
2199 vresult[i] = op(lvec[i]);
2200
2201 return vresult;
2202 }
2203
2132 Result total() const
2204 Result
2205 total() const
2133 {
2134 const VResult &vec = this->result();
2135 Result total = 0;
2136 for (int i = 0; i < size(); i++)
2137 total += vec[i];
2138 return total;
2139 }
2140
2141 virtual size_t size() const { return l->size(); }
2142
2206 {
2207 const VResult &vec = this->result();
2208 Result total = 0;
2209 for (int i = 0; i < size(); i++)
2210 total += vec[i];
2211 return total;
2212 }
2213
2214 virtual size_t size() const { return l->size(); }
2215
2143 virtual std::string str() const
2216 virtual std::string
2217 str() const
2144 {
2145 return OpString<Op>::str() + l->str();
2146 }
2147};
2148
2149template <class Op>
2150class BinaryNode : public Node
2151{
2152 public:
2153 NodePtr l;
2154 NodePtr r;
2155 mutable VResult vresult;
2156
2157 public:
2158 BinaryNode(NodePtr &a, NodePtr &b) : l(a), r(b) {}
2159
2218 {
2219 return OpString<Op>::str() + l->str();
2220 }
2221};
2222
2223template <class Op>
2224class BinaryNode : public Node
2225{
2226 public:
2227 NodePtr l;
2228 NodePtr r;
2229 mutable VResult vresult;
2230
2231 public:
2232 BinaryNode(NodePtr &a, NodePtr &b) : l(a), r(b) {}
2233
2160 const VResult &result() const
2234 const VResult &
2235 result() const
2161 {
2162 Op op;
2163 const VResult &lvec = l->result();
2164 const VResult &rvec = r->result();
2165
2166 assert(lvec.size() > 0 && rvec.size() > 0);
2167
2168 if (lvec.size() == 1 && rvec.size() == 1) {

--- 14 unchanged lines hidden (view full) ---

2183 vresult.resize(size);
2184 for (int i = 0; i < size; ++i)
2185 vresult[i] = op(lvec[i], rvec[i]);
2186 }
2187
2188 return vresult;
2189 }
2190
2236 {
2237 Op op;
2238 const VResult &lvec = l->result();
2239 const VResult &rvec = r->result();
2240
2241 assert(lvec.size() > 0 && rvec.size() > 0);
2242
2243 if (lvec.size() == 1 && rvec.size() == 1) {

--- 14 unchanged lines hidden (view full) ---

2258 vresult.resize(size);
2259 for (int i = 0; i < size; ++i)
2260 vresult[i] = op(lvec[i], rvec[i]);
2261 }
2262
2263 return vresult;
2264 }
2265
2191 Result total() const
2266 Result
2267 total() const
2192 {
2193 const VResult &vec = this->result();
2194 Result total = 0;
2195 for (int i = 0; i < size(); i++)
2196 total += vec[i];
2197 return total;
2198 }
2199
2268 {
2269 const VResult &vec = this->result();
2270 Result total = 0;
2271 for (int i = 0; i < size(); i++)
2272 total += vec[i];
2273 return total;
2274 }
2275
2200 virtual size_t size() const {
2276 virtual size_t
2277 size() const
2278 {
2201 int ls = l->size();
2202 int rs = r->size();
2279 int ls = l->size();
2280 int rs = r->size();
2203 if (ls == 1)
2281 if (ls == 1) {
2204 return rs;
2282 return rs;
2205 else if (rs == 1)
2283 } else if (rs == 1) {
2206 return ls;
2284 return ls;
2207 else {
2285 } else {
2208 assert(ls == rs && "Node vector sizes are not equal");
2209 return ls;
2210 }
2211 }
2212
2286 assert(ls == rs && "Node vector sizes are not equal");
2287 return ls;
2288 }
2289 }
2290
2213 virtual std::string str() const
2291 virtual std::string
2292 str() const
2214 {
2215 return csprintf("(%s %s %s)", l->str(), OpString<Op>::str(), r->str());
2216 }
2217};
2218
2219template <class Op>
2220class SumNode : public Node
2221{
2222 public:
2223 NodePtr l;
2224 mutable VResult vresult;
2225
2226 public:
2227 SumNode(NodePtr &p) : l(p), vresult(1) {}
2228
2293 {
2294 return csprintf("(%s %s %s)", l->str(), OpString<Op>::str(), r->str());
2295 }
2296};
2297
2298template <class Op>
2299class SumNode : public Node
2300{
2301 public:
2302 NodePtr l;
2303 mutable VResult vresult;
2304
2305 public:
2306 SumNode(NodePtr &p) : l(p), vresult(1) {}
2307
2229 const VResult &result() const
2308 const VResult &
2309 result() const
2230 {
2231 const VResult &lvec = l->result();
2232 int size = lvec.size();
2233 assert(size > 0);
2234
2235 vresult[0] = 0.0;
2236
2237 Op op;
2238 for (int i = 0; i < size; ++i)
2239 vresult[0] = op(vresult[0], lvec[i]);
2240
2241 return vresult;
2242 }
2243
2310 {
2311 const VResult &lvec = l->result();
2312 int size = lvec.size();
2313 assert(size > 0);
2314
2315 vresult[0] = 0.0;
2316
2317 Op op;
2318 for (int i = 0; i < size; ++i)
2319 vresult[0] = op(vresult[0], lvec[i]);
2320
2321 return vresult;
2322 }
2323
2244 Result total() const
2324 Result
2325 total() const
2245 {
2246 const VResult &lvec = l->result();
2247 int size = lvec.size();
2248 assert(size > 0);
2249
2250 Result vresult = 0.0;
2251
2252 Op op;
2253 for (int i = 0; i < size; ++i)
2254 vresult = op(vresult, lvec[i]);
2255
2256 return vresult;
2257 }
2258
2259 virtual size_t size() const { return 1; }
2260
2326 {
2327 const VResult &lvec = l->result();
2328 int size = lvec.size();
2329 assert(size > 0);
2330
2331 Result vresult = 0.0;
2332
2333 Op op;
2334 for (int i = 0; i < size; ++i)
2335 vresult = op(vresult, lvec[i]);
2336
2337 return vresult;
2338 }
2339
2340 virtual size_t size() const { return 1; }
2341
2261 virtual std::string str() const
2342 virtual std::string
2343 str() const
2262 {
2263 return csprintf("total(%s)", l->str());
2264 }
2265};
2266
2267
2268//////////////////////////////////////////////////////////////////////
2269//

--- 33 unchanged lines hidden (view full) ---

2303
2304class Value : public Wrap<Value, ValueBase, ScalarStatData>
2305{
2306 public:
2307 /** The base implementation. */
2308 typedef ValueBase Base;
2309
2310 template <class T>
2344 {
2345 return csprintf("total(%s)", l->str());
2346 }
2347};
2348
2349
2350//////////////////////////////////////////////////////////////////////
2351//

--- 33 unchanged lines hidden (view full) ---

2385
2386class Value : public Wrap<Value, ValueBase, ScalarStatData>
2387{
2388 public:
2389 /** The base implementation. */
2390 typedef ValueBase Base;
2391
2392 template <class T>
2311 Value &scalar(T &value)
2393 Value &
2394 scalar(T &value)
2312 {
2313 Base::scalar(value);
2314 return *this;
2315 }
2316
2317 template <class T>
2395 {
2396 Base::scalar(value);
2397 return *this;
2398 }
2399
2400 template <class T>
2318 Value &functor(T &func)
2401 Value &
2402 functor(T &func)
2319 {
2320 Base::functor(func);
2321 return *this;
2322 }
2323};
2324
2325/**
2326 * A stat that calculates the per tick average of a value.

--- 12 unchanged lines hidden (view full) ---

2339 }
2340
2341 /**
2342 * Sets the stat equal to the given value. Calls the base implementation
2343 * of operator=
2344 * @param v The new value.
2345 */
2346 template <typename U>
2403 {
2404 Base::functor(func);
2405 return *this;
2406 }
2407};
2408
2409/**
2410 * A stat that calculates the per tick average of a value.

--- 12 unchanged lines hidden (view full) ---

2423 }
2424
2425 /**
2426 * Sets the stat equal to the given value. Calls the base implementation
2427 * of operator=
2428 * @param v The new value.
2429 */
2430 template <typename U>
2347 void operator=(const U &v) { Base::operator=(v); }
2431 void
2432 operator=(const U &v)
2433 {
2434 Base::operator=(v);
2435 }
2348};
2349
2350/**
2351 * A vector of scalar stats.
2352 * @sa Stat, VectorBase, StatStor
2353 */
2354template<int N = 0>
2355class Vector : public WrapVec<Vector<N>, VectorBase<StatStor>, VectorStatData>
2356{
2357 public:
2358 /** The base implementation. */
2359 typedef ScalarBase<StatStor> Base;
2360
2361 /**
2362 * Set this vector to have the given size.
2363 * @param size The new size.
2364 * @return A reference to this stat.
2365 */
2436};
2437
2438/**
2439 * A vector of scalar stats.
2440 * @sa Stat, VectorBase, StatStor
2441 */
2442template<int N = 0>
2443class Vector : public WrapVec<Vector<N>, VectorBase<StatStor>, VectorStatData>
2444{
2445 public:
2446 /** The base implementation. */
2447 typedef ScalarBase<StatStor> Base;
2448
2449 /**
2450 * Set this vector to have the given size.
2451 * @param size The new size.
2452 * @return A reference to this stat.
2453 */
2366 Vector &init(size_t size) {
2454 Vector &
2455 init(size_t size)
2456 {
2367 this->doInit(size);
2368 return *this;
2369 }
2370};
2371
2372/**
2373 * A vector of Average stats.
2374 * @sa Stat, VectorBase, AvgStor
2375 */
2376template<int N = 0>
2377class AverageVector
2378 : public WrapVec<AverageVector<N>, VectorBase<AvgStor>, VectorStatData>
2379{
2380 public:
2381 /**
2382 * Set this vector to have the given size.
2383 * @param size The new size.
2384 * @return A reference to this stat.
2385 */
2457 this->doInit(size);
2458 return *this;
2459 }
2460};
2461
2462/**
2463 * A vector of Average stats.
2464 * @sa Stat, VectorBase, AvgStor
2465 */
2466template<int N = 0>
2467class AverageVector
2468 : public WrapVec<AverageVector<N>, VectorBase<AvgStor>, VectorStatData>
2469{
2470 public:
2471 /**
2472 * Set this vector to have the given size.
2473 * @param size The new size.
2474 * @return A reference to this stat.
2475 */
2386 AverageVector &init(size_t size) {
2476 AverageVector &
2477 init(size_t size)
2478 {
2387 this->doInit(size);
2388 return *this;
2389 }
2390};
2391
2392/**
2393 * A 2-Dimensional vecto of scalar stats.
2394 * @sa Stat, Vector2dBase, StatStor
2395 */
2396template<int N = 0>
2397class Vector2d
2398 : public WrapVec2d<Vector2d<N>, Vector2dBase<StatStor>, Vector2dStatData>
2399{
2400 public:
2479 this->doInit(size);
2480 return *this;
2481 }
2482};
2483
2484/**
2485 * A 2-Dimensional vecto of scalar stats.
2486 * @sa Stat, Vector2dBase, StatStor
2487 */
2488template<int N = 0>
2489class Vector2d
2490 : public WrapVec2d<Vector2d<N>, Vector2dBase<StatStor>, Vector2dStatData>
2491{
2492 public:
2401 Vector2d &init(size_t x, size_t y) {
2493 Vector2d &
2494 init(size_t x, size_t y)
2495 {
2402 this->doInit(x, y);
2403 return *this;
2404 }
2405};
2406
2407/**
2408 * A simple distribution stat.
2409 * @sa Stat, DistBase, DistStor

--- 11 unchanged lines hidden (view full) ---

2421 public:
2422 /**
2423 * Set the parameters of this distribution. @sa DistStor::Params
2424 * @param min The minimum value of the distribution.
2425 * @param max The maximum value of the distribution.
2426 * @param bkt The number of values in each bucket.
2427 * @return A reference to this distribution.
2428 */
2496 this->doInit(x, y);
2497 return *this;
2498 }
2499};
2500
2501/**
2502 * A simple distribution stat.
2503 * @sa Stat, DistBase, DistStor

--- 11 unchanged lines hidden (view full) ---

2515 public:
2516 /**
2517 * Set the parameters of this distribution. @sa DistStor::Params
2518 * @param min The minimum value of the distribution.
2519 * @param max The maximum value of the distribution.
2520 * @param bkt The number of values in each bucket.
2521 * @return A reference to this distribution.
2522 */
2429 Distribution &init(Counter min, Counter max, Counter bkt) {
2523 Distribution &
2524 init(Counter min, Counter max, Counter bkt)
2525 {
2430 this->params.min = min;
2431 this->params.max = max;
2432 this->params.bucket_size = bkt;
2433 this->params.size = (int)rint((max - min) / bkt + 1.0);
2434 this->doInit();
2435 return *this;
2436 }
2437};

--- 11 unchanged lines hidden (view full) ---

2449 typedef DistBase<DistStor> Base;
2450 /** The parameter type. */
2451 typedef DistStor::Params Params;
2452
2453 public:
2454 /**
2455 * Construct and initialize this distribution.
2456 */
2526 this->params.min = min;
2527 this->params.max = max;
2528 this->params.bucket_size = bkt;
2529 this->params.size = (int)rint((max - min) / bkt + 1.0);
2530 this->doInit();
2531 return *this;
2532 }
2533};

--- 11 unchanged lines hidden (view full) ---

2545 typedef DistBase<DistStor> Base;
2546 /** The parameter type. */
2547 typedef DistStor::Params Params;
2548
2549 public:
2550 /**
2551 * Construct and initialize this distribution.
2552 */
2457 StandardDeviation() {
2553 StandardDeviation()
2554 {
2458 this->doInit();
2459 }
2460};
2461
2462/**
2463 * Calculates the per tick mean and variance of the samples.
2464 * @sa Stat, DistBase, AvgFancy
2465 */

--- 37 unchanged lines hidden (view full) ---

2503 /**
2504 * Initialize storage and parameters for this distribution.
2505 * @param size The size of the vector (the number of distributions).
2506 * @param min The minimum value of the distribution.
2507 * @param max The maximum value of the distribution.
2508 * @param bkt The number of values in each bucket.
2509 * @return A reference to this distribution.
2510 */
2555 this->doInit();
2556 }
2557};
2558
2559/**
2560 * Calculates the per tick mean and variance of the samples.
2561 * @sa Stat, DistBase, AvgFancy
2562 */

--- 37 unchanged lines hidden (view full) ---

2600 /**
2601 * Initialize storage and parameters for this distribution.
2602 * @param size The size of the vector (the number of distributions).
2603 * @param min The minimum value of the distribution.
2604 * @param max The maximum value of the distribution.
2605 * @param bkt The number of values in each bucket.
2606 * @return A reference to this distribution.
2607 */
2511 VectorDistribution &init(int size, Counter min, Counter max, Counter bkt) {
2608 VectorDistribution &
2609 init(int size, Counter min, Counter max, Counter bkt)
2610 {
2512 this->params.min = min;
2513 this->params.max = max;
2514 this->params.bucket_size = bkt;
2515 this->params.size = (int)rint((max - min) / bkt + 1.0);
2516 this->doInit(size);
2517 return *this;
2518 }
2519};

--- 15 unchanged lines hidden (view full) ---

2535 typedef DistStor::Params Params;
2536
2537 public:
2538 /**
2539 * Initialize storage for this distribution.
2540 * @param size The size of the vector.
2541 * @return A reference to this distribution.
2542 */
2611 this->params.min = min;
2612 this->params.max = max;
2613 this->params.bucket_size = bkt;
2614 this->params.size = (int)rint((max - min) / bkt + 1.0);
2615 this->doInit(size);
2616 return *this;
2617 }
2618};

--- 15 unchanged lines hidden (view full) ---

2634 typedef DistStor::Params Params;
2635
2636 public:
2637 /**
2638 * Initialize storage for this distribution.
2639 * @param size The size of the vector.
2640 * @return A reference to this distribution.
2641 */
2543 VectorStandardDeviation &init(int size) {
2642 VectorStandardDeviation &
2643 init(int size)
2644 {
2544 this->doInit(size);
2545 return *this;
2546 }
2547};
2548
2549/**
2550 * This is a vector of AverageDeviation stats.
2551 * @sa Stat, VectorDistBase, AvgFancy

--- 11 unchanged lines hidden (view full) ---

2563 typedef DistStor::Params Params;
2564
2565 public:
2566 /**
2567 * Initialize storage for this distribution.
2568 * @param size The size of the vector.
2569 * @return A reference to this distribution.
2570 */
2645 this->doInit(size);
2646 return *this;
2647 }
2648};
2649
2650/**
2651 * This is a vector of AverageDeviation stats.
2652 * @sa Stat, VectorDistBase, AvgFancy

--- 11 unchanged lines hidden (view full) ---

2664 typedef DistStor::Params Params;
2665
2666 public:
2667 /**
2668 * Initialize storage for this distribution.
2669 * @param size The size of the vector.
2670 * @return A reference to this distribution.
2671 */
2571 VectorAverageDeviation &init(int size) {
2672 VectorAverageDeviation &
2673 init(int size)
2674 {
2572 this->doInit(size);
2573 return *this;
2574 }
2575};
2576
2577/**
2578 * A formula for statistics that is calculated when printed. A formula is
2579 * stored as a tree of Nodes that represent the equation to calculate.

--- 70 unchanged lines hidden (view full) ---

2650
2651 public:
2652 FormulaStatData(Stat &stat) : s(stat) {}
2653
2654 virtual bool zero() const { return s.zero(); }
2655 virtual void reset() { s.reset(); }
2656
2657 virtual size_t size() const { return s.size(); }
2675 this->doInit(size);
2676 return *this;
2677 }
2678};
2679
2680/**
2681 * A formula for statistics that is calculated when printed. A formula is
2682 * stored as a tree of Nodes that represent the equation to calculate.

--- 70 unchanged lines hidden (view full) ---

2753
2754 public:
2755 FormulaStatData(Stat &stat) : s(stat) {}
2756
2757 virtual bool zero() const { return s.zero(); }
2758 virtual void reset() { s.reset(); }
2759
2760 virtual size_t size() const { return s.size(); }
2658 virtual const VResult &result() const
2761
2762 virtual const VResult &
2763 result() const
2659 {
2660 s.result(vec);
2661 return vec;
2662 }
2663 virtual Result total() const { return s.total(); }
2664 virtual VCounter &value() const { return cvec; }
2764 {
2765 s.result(vec);
2766 return vec;
2767 }
2768 virtual Result total() const { return s.total(); }
2769 virtual VCounter &value() const { return cvec; }
2665 virtual void visit(Visit &visitor)
2770
2771 virtual void
2772 visit(Visit &visitor)
2666 {
2667 update();
2668 s.update(this);
2669 visitor.visit(*this);
2670 }
2773 {
2774 update();
2775 s.update(this);
2776 visitor.visit(*this);
2777 }
2778
2671 virtual std::string str() const { return s.str(); }
2672};
2673
2674class Temp;
2675class Formula
2676 : public WrapVec<Formula,
2677 FormulaBase,
2678 FormulaStatData>

--- 68 unchanged lines hidden (view full) ---

2747
2748 public:
2749 /**
2750 * Create a new ScalarStatNode.
2751 * @param s The ScalarStat to place in a node.
2752 */
2753 template <int N>
2754 Temp(const Scalar<N> &s)
2779 virtual std::string str() const { return s.str(); }
2780};
2781
2782class Temp;
2783class Formula
2784 : public WrapVec<Formula,
2785 FormulaBase,
2786 FormulaStatData>

--- 68 unchanged lines hidden (view full) ---

2855
2856 public:
2857 /**
2858 * Create a new ScalarStatNode.
2859 * @param s The ScalarStat to place in a node.
2860 */
2861 template <int N>
2862 Temp(const Scalar<N> &s)
2755 : node(new ScalarStatNode(s.statData())) { }
2863 : node(new ScalarStatNode(s.statData()))
2864 { }
2756
2757 /**
2758 * Create a new ScalarStatNode.
2759 * @param s The ScalarStat to place in a node.
2760 */
2761 Temp(const Value &s)
2865
2866 /**
2867 * Create a new ScalarStatNode.
2868 * @param s The ScalarStat to place in a node.
2869 */
2870 Temp(const Value &s)
2762 : node(new ScalarStatNode(s.statData())) { }
2871 : node(new ScalarStatNode(s.statData()))
2872 { }
2763
2764 /**
2765 * Create a new ScalarStatNode.
2766 * @param s The ScalarStat to place in a node.
2767 */
2768 template <int N>
2769 Temp(const Average<N> &s)
2873
2874 /**
2875 * Create a new ScalarStatNode.
2876 * @param s The ScalarStat to place in a node.
2877 */
2878 template <int N>
2879 Temp(const Average<N> &s)
2770 : node(new ScalarStatNode(s.statData())) { }
2880 : node(new ScalarStatNode(s.statData()))
2881 { }
2771
2772 /**
2773 * Create a new VectorStatNode.
2774 * @param s The VectorStat to place in a node.
2775 */
2776 template <int N>
2777 Temp(const Vector<N> &s)
2882
2883 /**
2884 * Create a new VectorStatNode.
2885 * @param s The VectorStat to place in a node.
2886 */
2887 template <int N>
2888 Temp(const Vector<N> &s)
2778 : node(new VectorStatNode(s.statData())) { }
2889 : node(new VectorStatNode(s.statData()))
2890 { }
2779
2780 /**
2781 *
2782 */
2783 Temp(const Formula &f)
2891
2892 /**
2893 *
2894 */
2895 Temp(const Formula &f)
2784 : node(new FormulaNode(f)) { }
2896 : node(new FormulaNode(f))
2897 { }
2785
2786 /**
2787 * Create a new ScalarProxyNode.
2788 * @param p The ScalarProxy to place in a node.
2789 */
2790 template <class Stat>
2791 Temp(const ScalarProxy<Stat> &p)
2898
2899 /**
2900 * Create a new ScalarProxyNode.
2901 * @param p The ScalarProxy to place in a node.
2902 */
2903 template <class Stat>
2904 Temp(const ScalarProxy<Stat> &p)
2792 : node(new ScalarProxyNode<Stat>(p)) { }
2905 : node(new ScalarProxyNode(p))
2906 { }
2793
2794 /**
2795 * Create a ConstNode
2796 * @param value The value of the const node.
2797 */
2798 Temp(signed char value)
2907
2908 /**
2909 * Create a ConstNode
2910 * @param value The value of the const node.
2911 */
2912 Temp(signed char value)
2799 : node(new ConstNode<signed char>(value)) {}
2913 : node(new ConstNode(value))
2914 { }
2800
2801 /**
2802 * Create a ConstNode
2803 * @param value The value of the const node.
2804 */
2805 Temp(unsigned char value)
2915
2916 /**
2917 * Create a ConstNode
2918 * @param value The value of the const node.
2919 */
2920 Temp(unsigned char value)
2806 : node(new ConstNode<unsigned char>(value)) {}
2921 : node(new ConstNode(value))
2922 { }
2807
2808 /**
2809 * Create a ConstNode
2810 * @param value The value of the const node.
2811 */
2812 Temp(signed short value)
2923
2924 /**
2925 * Create a ConstNode
2926 * @param value The value of the const node.
2927 */
2928 Temp(signed short value)
2813 : node(new ConstNode<signed short>(value)) {}
2929 : node(new ConstNode(value))
2930 { }
2814
2815 /**
2816 * Create a ConstNode
2817 * @param value The value of the const node.
2818 */
2819 Temp(unsigned short value)
2931
2932 /**
2933 * Create a ConstNode
2934 * @param value The value of the const node.
2935 */
2936 Temp(unsigned short value)
2820 : node(new ConstNode<unsigned short>(value)) {}
2937 : node(new ConstNode(value))
2938 { }
2821
2822 /**
2823 * Create a ConstNode
2824 * @param value The value of the const node.
2825 */
2826 Temp(signed int value)
2939
2940 /**
2941 * Create a ConstNode
2942 * @param value The value of the const node.
2943 */
2944 Temp(signed int value)
2827 : node(new ConstNode<signed int>(value)) {}
2945 : node(new ConstNode(value))
2946 { }
2828
2829 /**
2830 * Create a ConstNode
2831 * @param value The value of the const node.
2832 */
2833 Temp(unsigned int value)
2947
2948 /**
2949 * Create a ConstNode
2950 * @param value The value of the const node.
2951 */
2952 Temp(unsigned int value)
2834 : node(new ConstNode<unsigned int>(value)) {}
2953 : node(new ConstNode(value))
2954 { }
2835
2836 /**
2837 * Create a ConstNode
2838 * @param value The value of the const node.
2839 */
2840 Temp(signed long value)
2955
2956 /**
2957 * Create a ConstNode
2958 * @param value The value of the const node.
2959 */
2960 Temp(signed long value)
2841 : node(new ConstNode<signed long>(value)) {}
2961 : node(new ConstNode(value))
2962 { }
2842
2843 /**
2844 * Create a ConstNode
2845 * @param value The value of the const node.
2846 */
2847 Temp(unsigned long value)
2963
2964 /**
2965 * Create a ConstNode
2966 * @param value The value of the const node.
2967 */
2968 Temp(unsigned long value)
2848 : node(new ConstNode<unsigned long>(value)) {}
2969 : node(new ConstNode(value))
2970 { }
2849
2850 /**
2851 * Create a ConstNode
2852 * @param value The value of the const node.
2853 */
2854 Temp(signed long long value)
2971
2972 /**
2973 * Create a ConstNode
2974 * @param value The value of the const node.
2975 */
2976 Temp(signed long long value)
2855 : node(new ConstNode<signed long long>(value)) {}
2977 : node(new ConstNode(value))
2978 { }
2856
2857 /**
2858 * Create a ConstNode
2859 * @param value The value of the const node.
2860 */
2861 Temp(unsigned long long value)
2979
2980 /**
2981 * Create a ConstNode
2982 * @param value The value of the const node.
2983 */
2984 Temp(unsigned long long value)
2862 : node(new ConstNode<unsigned long long>(value)) {}
2985 : node(new ConstNode(value))
2986 { }
2863
2864 /**
2865 * Create a ConstNode
2866 * @param value The value of the const node.
2867 */
2868 Temp(float value)
2987
2988 /**
2989 * Create a ConstNode
2990 * @param value The value of the const node.
2991 */
2992 Temp(float value)
2869 : node(new ConstNode<float>(value)) {}
2993 : node(new ConstNode(value))
2994 { }
2870
2871 /**
2872 * Create a ConstNode
2873 * @param value The value of the const node.
2874 */
2875 Temp(double value)
2995
2996 /**
2997 * Create a ConstNode
2998 * @param value The value of the const node.
2999 */
3000 Temp(double value)
2876 : node(new ConstNode<double>(value)) {}
3001 : node(new ConstNode(value))
3002 { }
2877};
2878
2879
2880/**
2881 * @}
2882 */
2883
2884void check();

--- 57 unchanged lines hidden --- 		3003};
3004
3005
3006/**
3007 * @}
3008 */
3009
3010void check();

--- 57 unchanged lines hidden ---