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;
--- 46 unchanged lines hidden (view full) ---
55#include <iosfwd>
56#include <string>
57#include <vector>
58
59#include "base/cprintf.hh"
60#include "base/intmath.hh"
61#include "base/refcnt.hh"
62#include "base/str.hh"
63#include "base/stats/bin.hh"
64#include "base/stats/flags.hh"
65#include "base/stats/visit.hh"
66#include "base/stats/types.hh"
67#include "config/stats_binning.hh"
68#include "sim/host.hh"
69
70class Callback;
71
72/** The current simulated cycle. */
73extern Tick curTick;
74
75/* A namespace for all of the Statistics */
--- 22 unchanged lines hidden (view full) ---
98 * Can be used externally for lookups as well as for debugging.
99 */
100 int id;
101
102 StatData();
103 virtual ~StatData();
104
105 /**
106 * @return true if the stat is binned.
107 */
108 virtual bool binned() const = 0;
109
110 /**
111 * Reset the corresponding stat to the default state.
112 */
113 virtual void reset() = 0;
114
115 /**
116 * @return true if this stat has a value and satisfies its
117 * requirement as a prereq
118 */
--- 36 unchanged lines hidden (view full) ---
155class ScalarStatData : public ScalarData
156{
157 protected:
158 Stat &s;
159
160 public:
161 ScalarStatData(Stat &stat) : s(stat) {}
162
163 virtual bool binned() const { return s.binned(); }
164 virtual bool check() const { return s.check(); }
165 virtual Counter value() const { return s.value(); }
166 virtual Result result() const { return s.result(); }
167 virtual Result total() const { return s.total(); }
168 virtual void reset() { s.reset(); }
169 virtual bool zero() const { return s.zero(); }
170};
171
--- 26 unchanged lines hidden (view full) ---
198 protected:
199 Stat &s;
200 mutable VCounter cvec;
201 mutable VResult rvec;
202
203 public:
204 VectorStatData(Stat &stat) : s(stat) {}
205
206 virtual bool binned() const { return s.binned(); }
207 virtual bool check() const { return s.check(); }
208 virtual bool zero() const { return s.zero(); }
209 virtual void reset() { s.reset(); }
210
211 virtual size_t size() const { return s.size(); }
212 virtual VCounter &value() const
213 {
214 s.value(cvec);
--- 41 unchanged lines hidden (view full) ---
256class DistStatData : public DistData
257{
258 protected:
259 Stat &s;
260
261 public:
262 DistStatData(Stat &stat) : s(stat) {}
263
264 virtual bool binned() const { return s.binned(); }
265 virtual bool check() const { return s.check(); }
266 virtual void reset() { s.reset(); }
267 virtual bool zero() const { return s.zero(); }
268 virtual void visit(Visit &visitor)
269 {
270 s.update(this);
271 visitor.visit(*this);
272 }
--- 22 unchanged lines hidden (view full) ---
295 }
296};
297
298template <class Stat>
299class VectorDistStatData : public VectorDistData
300{
301 protected:
302 Stat &s;
303 typedef typename Stat::bin_t bin_t;
304
305 public:
306 VectorDistStatData(Stat &stat) : s(stat) {}
307
308 virtual bool binned() const { return bin_t::binned; }
309 virtual bool check() const { return s.check(); }
310 virtual void reset() { s.reset(); }
311 virtual size_t size() const { return s.size(); }
312 virtual bool zero() const { return s.zero(); }
313 virtual void visit(Visit &visitor)
314 {
315 update();
316 s.update(this);
--- 20 unchanged lines hidden (view full) ---
337 }
338};
339
340template <class Stat>
341class Vector2dStatData : public Vector2dData
342{
343 protected:
344 Stat &s;
345 typedef typename Stat::bin_t bin_t;
346
347 public:
348 Vector2dStatData(Stat &stat) : s(stat) {}
349
350 virtual bool binned() const { return bin_t::binned; }
351 virtual bool check() const { return s.check(); }
352 virtual void reset() { s.reset(); }
353 virtual bool zero() const { return s.zero(); }
354 virtual void visit(Visit &visitor)
355 {
356 update();
357 s.update(this);
358 visitor.visit(*this);
359 }
360};
361
362
363class DataAccess
364{
365 protected:
366 StatData *find() const;
367 void map(StatData *data);
368
369 StatData *statData();
370 const StatData *statData() const;
--- 239 unchanged lines hidden (view full) ---
610};
611
612/**
613 * Templatized storage and interface to a per-cycle average stat. This keeps
614 * a current count and updates a total (count * cycles) when this count
615 * changes. This allows the quick calculation of a per cycle count of the item
616 * being watched. This is good for keeping track of residencies in structures
617 * among other things.
618 * @todo add lateny to the stat and fix binning.
619 */
620struct AvgStor
621{
622 public:
623 /** The paramaters for this storage type */
624 struct Params
625 {
626 /**
627 * The current count. We stash this here because the current
628 * value is not a binned value.
629 */
630 Counter current;
631 };
632
633 private:
634 /** The total count for all cycles. */
635 mutable Result total;
636 /** The cycle that current last changed. */
637 mutable Tick last;
638
639 public:
640 /**
641 * Build and initializes this stat storage.
642 */
643 AvgStor(Params &p) : total(0), last(0) { p.current = Counter(); }
644
645 /**
646 * Set the current count to the one provided, update the total and last
647 * set values.
648 * @param val The new count.
649 * @param p The parameters for this storage.
650 */
651 void set(Counter val, Params &p) {
652 total += p.current * (curTick - last);
653 last = curTick;
654 p.current = val;
655 }
656
657 /**
658 * Increment the current count by the provided value, calls set.
659 * @param val The amount to increment.
660 * @param p The parameters for this storage.
661 */
662 void inc(Counter val, Params &p) { set(p.current + val, p); }
663
664 /**
665 * Deccrement the current count by the provided value, calls set.
666 * @param val The amount to decrement.
667 * @param p The parameters for this storage.
668 */
669 void dec(Counter val, Params &p) { set(p.current - val, p); }
670
671 /**
672 * Return the current count.
673 * @param p The parameters for this storage.
674 * @return The current count.
675 */
676 Counter value(const Params &p) const { return p.current; }
677
678 /**
679 * Return the current average.
680 * @param p The parameters for this storage.
681 * @return The current average.
682 */
683 Result result(const Params &p) const
684 {
685 total += p.current * (curTick - last);
686 last = curTick;
687 return (Result)(total + p.current) / (Result)(curTick + 1);
688 }
689
690 /**
691 * Reset stat value to default
692 */
693 void reset()
694 {
695 total = 0;
696 last = curTick;
697 }
698
699 /**
700 * @return true if zero value
701 */
702 bool zero() const { return total == 0.0; }
703};
704
705/**
706 * Implementation of a scalar stat. The type of stat is determined by the
707 * Storage template. The storage for this stat is held within the Bin class.
708 * This allows for breaking down statistics across multiple bins easily.
709 */
710template <class Storage, class Bin>
711class ScalarBase : public DataAccess
712{
713 public:
714 /** Define the params of the storage class. */
715 typedef typename Storage::Params params_t;
716 /** Define the bin type. */
717 typedef typename Bin::template Bin<Storage> bin_t;
718
719 protected:
720 /** The bin of this stat. */
721 bin_t bin;
722 /** The parameters for this stat. */
723 params_t params;
724
725 protected:
726 /**
727 * Retrieve the storage from the bin.
728 * @return The storage object for this stat.
729 */
730 Storage *data() { return bin.data(params); }
731 /**
732 * Retrieve a const pointer to the storage from the bin.
733 * @return A const pointer to the storage object for this stat.
734 */
735 const Storage *data() const
736 {
737 bin_t *_bin = const_cast<bin_t *>(&bin);
738 params_t *_params = const_cast<params_t *>(¶ms);
739 return _bin->data(*_params);
740 }
741
742 public:
743 /**
744 * Return the current value of this stat as its base type.
745 * @return The current value.
746 */
747 Counter value() const { return data()->value(params); }
748
749 public:
750 /**
751 * Create and initialize this stat, register it with the database.
752 */
753 ScalarBase()
754 {
755 bin.init(params);
756 }
757
758 public:
759 // Common operators for stats
760 /**
761 * Increment the stat by 1. This calls the associated storage object inc
762 * function.
763 */
764 void operator++() { data()->inc(1, params); }
--- 32 unchanged lines hidden (view full) ---
797 template <typename U>
798 void operator-=(const U &v) { data()->dec(v, params); }
799
800 /**
801 * Return the number of elements, always 1 for a scalar.
802 * @return 1.
803 */
804 size_t size() const { return 1; }
805 /**
806 * Return true if stat is binned.
807 *@return True is stat is binned.
808 */
809 bool binned() const { return bin_t::binned; }
810
811 bool check() const { return bin.initialized(); }
812
813 /**
814 * Reset stat value to default
815 */
816 void reset() { bin.reset(); }
817
818 Counter value() { return data()->value(params); }
819
820 Result result() { return data()->result(params); }
821
822 Result total() { return result(); }
823
824 bool zero() { return result() == 0.0; }
825
826};
827
828class ProxyData : public ScalarData
829{
830 public:
831 virtual void visit(Visit &visitor) { visitor.visit(*this); }
832 virtual bool binned() const { return false; }
833 virtual std::string str() const { return to_string(value()); }
834 virtual size_t size() const { return 1; }
835 virtual bool zero() const { return value() == 0; }
836 virtual bool check() const { return true; }
837 virtual void reset() { }
838};
839
840template <class T>
--- 45 unchanged lines hidden (view full) ---
886 setInit();
887 }
888
889 Counter value() { return proxy->value(); }
890 Result result() const { return proxy->result(); }
891 Result total() const { return proxy->total(); };
892 size_t size() const { return proxy->size(); }
893
894 bool binned() const { return proxy->binned(); }
895 std::string str() const { return proxy->str(); }
896 bool zero() const { return proxy->zero(); }
897 bool check() const { return proxy != NULL; }
898 void reset() { }
899};
900
901//////////////////////////////////////////////////////////////////////
902//
903// Vector Statistics
904//
905//////////////////////////////////////////////////////////////////////
906template <class Storage, class Bin>
907class ScalarProxy;
908
909/**
910 * Implementation of a vector of stats. The type of stat is determined by the
911 * Storage class. @sa ScalarBase
912 */
913template <class Storage, class Bin>
914class VectorBase : public DataAccess
915{
916 public:
917 /** Define the params of the storage class. */
918 typedef typename Storage::Params params_t;
919 /** Define the bin type. */
920 typedef typename Bin::template VectorBin<Storage> bin_t;
921
922 protected:
923 /** The bin of this stat. */
924 bin_t bin;
925 /** The parameters for this stat. */
926 params_t params;
927
928 protected:
929 /**
930 * Retrieve the storage from the bin for the given index.
931 * @param index The vector index to access.
932 * @return The storage object at the given index.
933 */
934 Storage *data(int index) { return bin.data(index, params); }
935 /**
936 * Retrieve a const pointer to the storage from the bin
937 * for the given index.
938 * @param index The vector index to access.
939 * @return A const pointer to the storage object at the given index.
940 */
941 const Storage *data(int index) const
942 {
943 bin_t *_bin = const_cast<bin_t *>(&bin);
944 params_t *_params = const_cast<params_t *>(¶ms);
945 return _bin->data(index, *_params);
946 }
947
948 public:
949 void value(VCounter &vec) const
950 {
951 vec.resize(size());
952 for (int i = 0; i < size(); ++i)
953 vec[i] = data(i)->value(params);
954 }
955
956 /**
957 * Copy the values to a local vector and return a reference to it.
958 * @return A reference to a vector of the stat values.
959 */
960 void result(VResult &vec) const
961 {
962 vec.resize(size());
963 for (int i = 0; i < size(); ++i)
964 vec[i] = data(i)->result(params);
965 }
966
967 /**
968 * @return True is stat is binned.
969 */
970 bool binned() const { return bin_t::binned; }
971
972 /**
973 * Return a total of all entries in this vector.
974 * @return The total of all vector entries.
975 */
976 Result total() const {
977 Result total = 0.0;
978 for (int i = 0; i < size(); ++i)
979 total += data(i)->result(params);
980 return total;
981 }
982
983 /**
984 * @return the number of elements in this vector.
985 */
986 size_t size() const { return bin.size(); }
987
988 bool zero() const
989 {
990 for (int i = 0; i < size(); ++i)
991 if (data(i)->zero())
992 return true;
993 return false;
994 }
995
996 bool check() const { return bin.initialized(); }
997 void reset() { bin.reset(); }
998
999 public:
1000 VectorBase() {}
1001
1002 /** Friend this class with the associated scalar proxy. */
1003 friend class ScalarProxy<Storage, Bin>;
1004
1005 /**
1006 * Return a reference (ScalarProxy) to the stat at the given index.
1007 * @param index The vector index to access.
1008 * @return A reference of the stat.
1009 */
1010 ScalarProxy<Storage, Bin> operator[](int index);
1011
1012 void update(StatData *data) {}
1013};
1014
1015const StatData * getStatData(const void *stat);
1016
1017/**
1018 * A proxy class to access the stat at a given index in a VectorBase stat.
1019 * Behaves like a ScalarBase.
1020 */
1021template <class Storage, class Bin>
1022class ScalarProxy
1023{
1024 public:
1025 /** Define the params of the storage class. */
1026 typedef typename Storage::Params params_t;
1027 /** Define the bin type. */
1028 typedef typename Bin::template VectorBin<Storage> bin_t;
1029
1030 private:
1031 /** Pointer to the bin in the parent VectorBase. */
1032 bin_t *bin;
1033 /** Pointer to the params in the parent VectorBase. */
1034 params_t *params;
1035 /** The index to access in the parent VectorBase. */
1036 int index;
1037 /** Keep a pointer to the original stat so was can get data */
1038 void *stat;
1039
1040 protected:
1041 /**
1042 * Retrieve the storage from the bin.
1043 * @return The storage from the bin for this stat.
1044 */
1045 Storage *data() { return bin->data(index, *params); }
1046 /**
1047 * Retrieve a const pointer to the storage from the bin.
1048 * @return A const pointer to the storage for this stat.
1049 */
1050 const Storage *data() const
1051 {
1052 bin_t *_bin = const_cast<bin_t *>(bin);
1053 params_t *_params = const_cast<params_t *>(params);
1054 return _bin->data(index, *_params);
1055 }
1056
1057 public:
1058 /**
1059 * Return the current value of this stat as its base type.
1060 * @return The current value.
1061 */
1062 Counter value() const { return data()->value(*params); }
1063
1064 /**
1065 * Return the current value of this statas a result type.
1066 * @return The current value.
1067 */
1068 Result result() const { return data()->result(*params); }
1069
1070 public:
1071 /**
1072 * Create and initialize this proxy, do not register it with the database.
1073 * @param b The bin to use.
1074 * @param p The params to use.
1075 * @param i The index to access.
1076 */
1077 ScalarProxy(bin_t &b, params_t &p, int i, void *s)
1078 : bin(&b), params(&p), index(i), stat(s) {}
1079 /**
1080 * Create a copy of the provided ScalarProxy.
1081 * @param sp The proxy to copy.
1082 */
1083 ScalarProxy(const ScalarProxy &sp)
1084 : bin(sp.bin), params(sp.params), index(sp.index), stat(sp.stat) {}
1085 /**
1086 * Set this proxy equal to the provided one.
1087 * @param sp The proxy to copy.
1088 * @return A reference to this proxy.
1089 */
1090 const ScalarProxy &operator=(const ScalarProxy &sp) {
1091 bin = sp.bin;
1092 params = sp.params;
1093 index = sp.index;
1094 stat = sp.stat;
1095 return *this;
1096 }
1097
1098 public:
1099 // Common operators for stats
1100 /**
1101 * Increment the stat by 1. This calls the associated storage object inc
1102 * function.
1103 */
1104 void operator++() { data()->inc(1, *params); }
1105 /**
1106 * Decrement the stat by 1. This calls the associated storage object dec
1107 * function.
1108 */
1109 void operator--() { data()->dec(1, *params); }
1110
1111 /** Increment the stat by 1. */
1112 void operator++(int) { ++*this; }
1113 /** Decrement the stat by 1. */
1114 void operator--(int) { --*this; }
1115
1116 /**
1117 * Set the data value to the given value. This calls the associated storage
1118 * object set function.
1119 * @param v The new value.
1120 */
1121 template <typename U>
1122 void operator=(const U &v) { data()->set(v, *params); }
1123
1124 /**
1125 * Increment the stat by the given value. This calls the associated
1126 * storage object inc function.
1127 * @param v The value to add.
1128 */
1129 template <typename U>
1130 void operator+=(const U &v) { data()->inc(v, *params); }
1131
1132 /**
1133 * Decrement the stat by the given value. This calls the associated
1134 * storage object dec function.
1135 * @param v The value to substract.
1136 */
1137 template <typename U>
1138 void operator-=(const U &v) { data()->dec(v, *params); }
1139
1140 /**
1141 * Return the number of elements, always 1 for a scalar.
1142 * @return 1.
1143 */
1144 size_t size() const { return 1; }
1145
1146 /**
1147 * Return true if stat is binned.
1148 *@return false since Proxies aren't printed/binned
1149 */
1150 bool binned() const { return false; }
1151
1152 /**
1153 * This stat has no state. Nothing to reset
1154 */
1155 void reset() { }
1156
1157 public:
1158 const StatData *statData() const { return getStatData(stat); }
1159 std::string str() const
1160 {
1161 return csprintf("%s[%d]", this->statData()->name, index);
1162
1163 }
1164};
1165
1166template <class Storage, class Bin>
1167inline ScalarProxy<Storage, Bin>
1168VectorBase<Storage, Bin>::operator[](int index)
1169{
1170 assert (index >= 0 && index < size());
1171 return ScalarProxy<Storage, Bin>(bin, params, index, this);
1172}
1173
1174template <class Storage, class Bin>
1175class VectorProxy;
1176
1177template <class Storage, class Bin>
1178class Vector2dBase : public DataAccess
1179{
1180 public:
1181 typedef typename Storage::Params params_t;
1182 typedef typename Bin::template VectorBin<Storage> bin_t;
1183
1184 protected:
1185 size_t x;
1186 size_t y;
1187 bin_t bin;
1188 params_t params;
1189
1190 protected:
1191 Storage *data(int index) { return bin.data(index, params); }
1192 const Storage *data(int index) const
1193 {
1194 bin_t *_bin = const_cast<bin_t *>(&bin);
1195 params_t *_params = const_cast<params_t *>(¶ms);
1196 return _bin->data(index, *_params);
1197 }
1198
1199 public:
1200 Vector2dBase() {}
1201
1202 void update(Vector2dData *data)
1203 {
1204 int size = this->size();
1205 data->cvec.resize(size);
1206 for (int i = 0; i < size; ++i)
1207 data->cvec[i] = this->data(i)->value(params);
1208 }
1209
1210 std::string ysubname(int i) const { return (*this->y_subnames)[i]; }
1211
1212 friend class VectorProxy<Storage, Bin>;
1213 VectorProxy<Storage, Bin> operator[](int index);
1214
1215 size_t size() const { return bin.size(); }
1216 bool zero() const { return data(0)->value(params) == 0.0; }
1217
1218 /**
1219 * Reset stat value to default
1220 */
1221 void reset() { bin.reset(); }
1222
1223 bool check() { return bin.initialized(); }
1224};
1225
1226template <class Storage, class Bin>
1227class VectorProxy
1228{
1229 public:
1230 typedef typename Storage::Params params_t;
1231 typedef typename Bin::template VectorBin<Storage> bin_t;
1232
1233 private:
1234 bin_t *bin;
1235 params_t *params;
1236 int offset;
1237 int len;
1238 void *stat;
1239
1240 private:
1241 mutable VResult *vec;
1242
1243 Storage *data(int index) {
1244 assert(index < len);
1245 return bin->data(offset + index, *params);
1246 }
1247
1248 const Storage *data(int index) const {
1249 bin_t *_bin = const_cast<bin_t *>(bin);
1250 params_t *_params = const_cast<params_t *>(params);
1251 return _bin->data(offset + index, *_params);
1252 }
1253
1254 public:
1255 const VResult &result() const {
1256 if (vec)
1257 vec->resize(size());
1258 else
1259 vec = new VResult(size());
1260
1261 for (int i = 0; i < size(); ++i)
1262 (*vec)[i] = data(i)->result(*params);
1263
1264 return *vec;
1265 }
1266
1267 Result total() const {
1268 Result total = 0.0;
1269 for (int i = 0; i < size(); ++i)
1270 total += data(i)->result(*params);
1271 return total;
1272 }
1273
1274 public:
1275 VectorProxy(bin_t &b, params_t &p, int o, int l, void *s)
1276 : bin(&b), params(&p), offset(o), len(l), stat(s), vec(NULL)
1277 {
1278 }
1279
1280 VectorProxy(const VectorProxy &sp)
1281 : bin(sp.bin), params(sp.params), offset(sp.offset), len(sp.len),
1282 stat(sp.stat), vec(NULL)
1283 {
1284 }
1285
1286 ~VectorProxy()
1287 {
1288 if (vec)
1289 delete vec;
1290 }
1291
1292 const VectorProxy &operator=(const VectorProxy &sp)
1293 {
1294 bin = sp.bin;
1295 params = sp.params;
1296 offset = sp.offset;
1297 len = sp.len;
1298 stat = sp.stat;
1299 if (vec)
1300 delete vec;
1301 vec = NULL;
1302 return *this;
1303 }
1304
1305 ScalarProxy<Storage, Bin> operator[](int index)
1306 {
1307 assert (index >= 0 && index < size());
1308 return ScalarProxy<Storage, Bin>(*bin, *params, offset + index, stat);
1309 }
1310
1311 size_t size() const { return len; }
1312
1313 /**
1314 * Return true if stat is binned.
1315 *@return false since Proxies aren't printed/binned
1316 */
1317 bool binned() const { return false; }
1318
1319 /**
1320 * This stat has no state. Nothing to reset.
1321 */
1322 void reset() { }
1323};
1324
1325template <class Storage, class Bin>
1326inline VectorProxy<Storage, Bin>
1327Vector2dBase<Storage, Bin>::operator[](int index)
1328{
1329 int offset = index * y;
1330 assert (index >= 0 && offset < size());
1331 return VectorProxy<Storage, Bin>(bin, params, offset, y, this);
1332}
1333
1334//////////////////////////////////////////////////////////////////////
1335//
1336// Non formula statistics
1337//
1338//////////////////////////////////////////////////////////////////////
1339
1340/**
1341 * Templatized storage and interface for a distrbution stat.
--- 29 unchanged lines hidden (view full) ---
1371 /** The sum of squares. */
1372 Counter squares;
1373 /** The number of samples. */
1374 Counter samples;
1375 /** Counter for each bucket. */
1376 VCounter cvec;
1377
1378 public:
1379 /**
1380 * Construct this storage with the supplied params.
1381 * @param params The parameters.
1382 */
1383 DistStor(const Params ¶ms)
1384 : min_val(INT_MAX), max_val(INT_MIN), underflow(Counter()),
1385 overflow(Counter()), sum(Counter()), squares(Counter()),
1386 samples(Counter()), cvec(params.size)
1387 {
1388 reset();
1389 }
1390
1391 /**
1392 * Add a value to the distribution for the given number of times.
1393 * @param val The value to add.
1394 * @param number The number of times to add the value.
--- 218 unchanged lines hidden (view full) ---
1613 squares = Counter();
1614 }
1615};
1616
1617/**
1618 * Implementation of a distribution stat. The type of distribution is
1619 * determined by the Storage template. @sa ScalarBase
1620 */
1621template <class Storage, class Bin>
1622class DistBase : public DataAccess
1623{
1624 public:
1625 /** Define the params of the storage class. */
1626 typedef typename Storage::Params params_t;
1627 /** Define the bin type. */
1628 typedef typename Bin::template Bin<Storage> bin_t;
1629
1630 protected:
1631 /** The bin of this stat. */
1632 bin_t bin;
1633 /** The parameters for this stat. */
1634 params_t params;
1635
1636 protected:
1637 /**
1638 * Retrieve the storage from the bin.
1639 * @return The storage object for this stat.
1640 */
1641 Storage *data() { return bin.data(params); }
1642 /**
1643 * Retrieve a const pointer to the storage from the bin.
1644 * @return A const pointer to the storage object for this stat.
1645 */
1646 const Storage *data() const
1647 {
1648 bin_t *_bin = const_cast<bin_t *>(&bin);
1649 params_t *_params = const_cast<params_t *>(¶ms);
1650 return _bin->data(*_params);
1651 }
1652
1653 public:
1654 DistBase() { }
1655
1656 /**
1657 * Add a value to the distribtion n times. Calls sample on the storage
1658 * class.
1659 * @param v The value to add.
1660 * @param n The number of times to add it, defaults to 1.
--- 12 unchanged lines hidden (view full) ---
1673 */
1674 bool zero() const { return data()->zero(params); }
1675
1676 void update(DistData *base)
1677 {
1678 base->data.fancy = Storage::fancy;
1679 data()->update(&(base->data), params);
1680 }
1681 /**
1682 * @return True is stat is binned.
1683 */
1684 bool binned() const { return bin_t::binned; }
1685 /**
1686 * Reset stat value to default
1687 */
1688 void reset()
1689 {
1690 bin.reset();
1691 }
1692
1693 bool check() { return bin.initialized(); }
1694};
1695
1696template <class Storage, class Bin>
1697class DistProxy;
1698
1699template <class Storage, class Bin>
1700class VectorDistBase : public DataAccess
1701{
1702 public:
1703 typedef typename Storage::Params params_t;
1704 typedef typename Bin::template VectorBin<Storage> bin_t;
1705
1706 protected:
1707 bin_t bin;
1708 params_t params;
1709
1710 protected:
1711 Storage *data(int index) { return bin.data(index, params); }
1712 const Storage *data(int index) const
1713 {
1714 bin_t *_bin = const_cast<bin_t *>(&bin);
1715 params_t *_params = const_cast<params_t *>(¶ms);
1716 return _bin->data(index, *_params);
1717 }
1718
1719 public:
1720 VectorDistBase() {}
1721
1722 friend class DistProxy<Storage, Bin>;
1723 DistProxy<Storage, Bin> operator[](int index);
1724 const DistProxy<Storage, Bin> operator[](int index) const;
1725
1726 size_t size() const { return bin.size(); }
1727 bool zero() const { return false; }
1728 /**
1729 * Return true if stat is binned.
1730 *@return True is stat is binned.
1731 */
1732 bool binned() const { return bin_t::binned; }
1733 /**
1734 * Reset stat value to default
1735 */
1736 void reset() { bin.reset(); }
1737
1738 bool check() { return bin.initialized(); }
1739 void update(VectorDistData *base)
1740 {
1741 int size = this->size();
1742 base->data.resize(size);
1743 for (int i = 0; i < size; ++i) {
1744 base->data[i].fancy = Storage::fancy;
1745 data(i)->update(&(base->data[i]), params);
1746 }
1747 }
1748};
1749
1750template <class Storage, class Bin>
1751class DistProxy
1752{
1753 public:
1754 typedef typename Storage::Params params_t;
1755 typedef typename Bin::template Bin<Storage> bin_t;
1756 typedef VectorDistBase<Storage, Bin> base_t;
1757
1758 private:
1759 union {
1760 base_t *stat;
1761 const base_t *cstat;
1762 };
1763 int index;
1764
1765 protected:
1766 Storage *data() { return stat->data(index); }
1767 const Storage *data() const { return cstat->data(index); }
1768
1769 public:
1770 DistProxy(const VectorDistBase<Storage, Bin> &s, int i)
1771 : cstat(&s), index(i) {}
1772 DistProxy(const DistProxy &sp)
1773 : cstat(sp.cstat), index(sp.index) {}
1774 const DistProxy &operator=(const DistProxy &sp) {
1775 cstat = sp.cstat; index = sp.index; return *this;
1776 }
1777
1778 public:
1779 template <typename U>
1780 void sample(const U &v, int n = 1) { data()->sample(v, n, cstat->params); }
1781
1782 size_t size() const { return 1; }
1783 bool zero() const { return data()->zero(cstat->params); }
1784 /**
1785 * Return true if stat is binned.
1786 *@return false since Proxies are not binned/printed.
1787 */
1788 bool binned() const { return false; }
1789 /**
1790 * Proxy has no state. Nothing to reset.
1791 */
1792 void reset() { }
1793};
1794
1795template <class Storage, class Bin>
1796inline DistProxy<Storage, Bin>
1797VectorDistBase<Storage, Bin>::operator[](int index)
1798{
1799 assert (index >= 0 && index < size());
1800 return DistProxy<Storage, Bin>(*this, index);
1801}
1802
1803template <class Storage, class Bin>
1804inline const DistProxy<Storage, Bin>
1805VectorDistBase<Storage, Bin>::operator[](int index) const
1806{
1807 assert (index >= 0 && index < size());
1808 return DistProxy<Storage, Bin>(*this, index);
1809}
1810
1811#if 0
1812template <class Storage, class Bin>
1813Result
1814VectorDistBase<Storage, Bin>::total(int index) const
1815{
1816 int total = 0;
1817 for (int i=0; i < x_size(); ++i) {
1818 total += data(i)->result(*params);
1819 }
1820}
1821#endif
1822
1823//////////////////////////////////////////////////////////////////////
1824//
1825// Formula Details
1826//
--- 16 unchanged lines hidden (view full) ---
1843 * @return The result vector of this subtree.
1844 */
1845 virtual const VResult &result() const = 0;
1846 /**
1847 * Return the total of the result vector.
1848 * @return The total of the result vector.
1849 */
1850 virtual Result total() const = 0;
1851 /**
1852 * Return true if stat is binned.
1853 *@return True is stat is binned.
1854 */
1855 virtual bool binned() const = 0;
1856
1857 /**
1858 *
1859 */
1860 virtual std::string str() const = 0;
1861};
1862
1863/** Reference counting pointer to a function Node. */
--- 10 unchanged lines hidden (view full) ---
1874 virtual const VResult &result() const
1875 {
1876 vresult[0] = data->result();
1877 return vresult;
1878 }
1879 virtual Result total() const { return data->result(); };
1880
1881 virtual size_t size() const { return 1; }
1882 /**
1883 * Return true if stat is binned.
1884 *@return True is stat is binned.
1885 */
1886 virtual bool binned() const { return data->binned(); }
1887
1888 /**
1889 *
1890 */
1891 virtual std::string str() const { return data->name; }
1892};
1893
1894template <class Storage, class Bin>
1895class ScalarProxyNode : public Node
1896{
1897 private:
1898 const ScalarProxy<Storage, Bin> proxy;
1899 mutable VResult vresult;
1900
1901 public:
1902 ScalarProxyNode(const ScalarProxy<Storage, Bin> &p)
1903 : proxy(p), vresult(1) { }
1904 virtual const VResult &result() const
1905 {
1906 vresult[0] = proxy.result();
1907 return vresult;
1908 }
1909 virtual Result total() const { return proxy.result(); };
1910
1911 virtual size_t size() const { return 1; }
1912 /**
1913 * Return true if stat is binned.
1914 *@return True is stat is binned.
1915 */
1916 virtual bool binned() const { return proxy.binned(); }
1917
1918 /**
1919 *
1920 */
1921 virtual std::string str() const { return proxy.str(); }
1922};
1923
1924class VectorStatNode : public Node
1925{
1926 private:
1927 const VectorData *data;
1928
1929 public:
1930 VectorStatNode(const VectorData *d) : data(d) { }
1931 virtual const VResult &result() const { return data->result(); }
1932 virtual Result total() const { return data->total(); };
1933
1934 virtual size_t size() const { return data->size(); }
1935 /**
1936 * Return true if stat is binned.
1937 *@return True is stat is binned.
1938 */
1939 virtual bool binned() const { return data->binned(); }
1940
1941 virtual std::string str() const { return data->name; }
1942};
1943
1944template <class T>
1945class ConstNode : public Node
1946{
1947 private:
1948 VResult vresult;
1949
1950 public:
1951 ConstNode(T s) : vresult(1, (Result)s) {}
1952 const VResult &result() const { return vresult; }
1953 virtual Result total() const { return vresult[0]; };
1954 virtual size_t size() const { return 1; }
1955
1956 /**
1957 * Return true if stat is binned.
1958 *@return False since constants aren't binned.
1959 */
1960 virtual bool binned() const { return false; }
1961
1962 virtual std::string str() const { return to_string(vresult[0]); }
1963};
1964
1965template <class Op>
1966struct OpString;
1967
1968template<>
1969struct OpString<std::plus<Result> >
--- 57 unchanged lines hidden (view full) ---
2027 }
2028
2029 Result total() const {
2030 Op op;
2031 return op(l->total());
2032 }
2033
2034 virtual size_t size() const { return l->size(); }
2035 /**
2036 * Return true if child of node is binned.
2037 *@return True if child of node is binned.
2038 */
2039 virtual bool binned() const { return l->binned(); }
2040
2041 virtual std::string str() const
2042 {
2043 return OpString<Op>::str() + l->str();
2044 }
2045};
2046
2047template <class Op>
--- 50 unchanged lines hidden (view full) ---
2098 return rs;
2099 else if (rs == 1)
2100 return ls;
2101 else {
2102 assert(ls == rs && "Node vector sizes are not equal");
2103 return ls;
2104 }
2105 }
2106 /**
2107 * Return true if any children of node are binned
2108 *@return True if either child of node is binned.
2109 */
2110 virtual bool binned() const { return (l->binned() || r->binned()); }
2111
2112 virtual std::string str() const
2113 {
2114 return csprintf("(%s %s %s)", l->str(), OpString<Op>::str(), r->str());
2115 }
2116};
2117
2118template <class Op>
--- 32 unchanged lines hidden (view full) ---
2151 Op op;
2152 for (int i = 0; i < size; ++i)
2153 vresult = op(vresult, lvec[i]);
2154
2155 return vresult;
2156 }
2157
2158 virtual size_t size() const { return 1; }
2159 /**
2160 * Return true if child of node is binned.
2161 *@return True if child of node is binned.
2162 */
2163 virtual bool binned() const { return l->binned(); }
2164
2165 virtual std::string str() const
2166 {
2167 return csprintf("total(%s)", l->str());
2168 }
2169};
2170
2171
2172//////////////////////////////////////////////////////////////////////
2173//
2174// Visible Statistics Types
2175//
2176//////////////////////////////////////////////////////////////////////
2177/**
2178 * @defgroup VisibleStats "Statistic Types"
2179 * These are the statistics that are used in the simulator. By default these
2180 * store counters and don't use binning, but are templatized to accept any type
2181 * and any Bin class.
2182 * @{
2183 */
2184
2185/**
2186 * This is an easy way to assign all your stats to be binned or not
2187 * binned. If the typedef is NoBin, nothing is binned. If it is
2188 * MainBin, then all stats are binned under that Bin.
2189 */
2190#if STATS_BINNING
2191typedef MainBin DefaultBin;
2192#else
2193typedef NoBin DefaultBin;
2194#endif
2195
2196/**
2197 * This is a simple scalar statistic, like a counter.
2198 * @sa Stat, ScalarBase, StatStor
2199 */
2200template <class Bin = DefaultBin>
2201class Scalar
2202 : public Wrap<Scalar<Bin>,
2203 ScalarBase<StatStor, Bin>,
2204 ScalarStatData>
2205{
2206 public:
2207 /** The base implementation. */
2208 typedef ScalarBase<StatStor, Bin> Base;
2209
2210 Scalar()
2211 {
2212 this->setInit();
2213 }
2214
2215 /**
2216 * Sets the stat equal to the given value. Calls the base implementation
2217 * of operator=
2218 * @param v The new value.
2219 */
2220 template <typename U>
2221 void operator=(const U &v) { Base::operator=(v); }
2222};
2223
2224class Value
2225 : public Wrap<Value,
2226 ValueBase,
2227 ScalarStatData>
2228{
2229 public:
2230 /** The base implementation. */
2231 typedef ValueBase Base;
2232
2233 template <class T>
2234 Value &scalar(T &value)
2235 {
--- 8 unchanged lines hidden (view full) ---
2244 return *this;
2245 }
2246};
2247
2248/**
2249 * A stat that calculates the per cycle average of a value.
2250 * @sa Stat, ScalarBase, AvgStor
2251 */
2252template <class Bin = DefaultBin>
2253class Average
2254 : public Wrap<Average<Bin>,
2255 ScalarBase<AvgStor, Bin>,
2256 ScalarStatData>
2257{
2258 public:
2259 /** The base implementation. */
2260 typedef ScalarBase<AvgStor, Bin> Base;
2261
2262 Average()
2263 {
2264 this->setInit();
2265 }
2266
2267 /**
2268 * Sets the stat equal to the given value. Calls the base implementation
2269 * of operator=
2270 * @param v The new value.
2271 */
2272 template <typename U>
2273 void operator=(const U &v) { Base::operator=(v); }
2274};
2275
2276/**
2277 * A vector of scalar stats.
2278 * @sa Stat, VectorBase, StatStor
2279 */
2280template <class Bin = DefaultBin>
2281class Vector
2282 : public WrapVec<Vector<Bin>,
2283 VectorBase<StatStor, Bin>,
2284 VectorStatData>
2285{
2286 public:
2287 /** The base implementation. */
2288 typedef ScalarBase<StatStor, Bin> Base;
2289
2290 /**
2291 * Set this vector to have the given size.
2292 * @param size The new size.
2293 * @return A reference to this stat.
2294 */
2295 Vector &init(size_t size) {
2296 this->bin.init(size, this->params);
2297 this->setInit();
2298
2299 return *this;
2300 }
2301};
2302
2303/**
2304 * A vector of Average stats.
2305 * @sa Stat, VectorBase, AvgStor
2306 */
2307template <class Bin = DefaultBin>
2308class AverageVector
2309 : public WrapVec<AverageVector<Bin>,
2310 VectorBase<AvgStor, Bin>,
2311 VectorStatData>
2312{
2313 public:
2314 /**
2315 * Set this vector to have the given size.
2316 * @param size The new size.
2317 * @return A reference to this stat.
2318 */
2319 AverageVector &init(size_t size) {
2320 this->bin.init(size, this->params);
2321 this->setInit();
2322
2323 return *this;
2324 }
2325};
2326
2327/**
2328 * A 2-Dimensional vecto of scalar stats.
2329 * @sa Stat, Vector2dBase, StatStor
2330 */
2331template <class Bin = DefaultBin>
2332class Vector2d
2333 : public WrapVec2d<Vector2d<Bin>,
2334 Vector2dBase<StatStor, Bin>,
2335 Vector2dStatData>
2336{
2337 public:
2338 Vector2d &init(size_t _x, size_t _y) {
2339 this->statData()->x = this->x = _x;
2340 this->statData()->y = this->y = _y;
2341 this->bin.init(this->x * this->y, this->params);
2342 this->setInit();
2343
2344 return *this;
2345 }
2346};
2347
2348/**
2349 * A simple distribution stat.
2350 * @sa Stat, DistBase, DistStor
2351 */
2352template <class Bin = DefaultBin>
2353class Distribution
2354 : public Wrap<Distribution<Bin>,
2355 DistBase<DistStor, Bin>,
2356 DistStatData>
2357{
2358 public:
2359 /** Base implementation. */
2360 typedef DistBase<DistStor, Bin> Base;
2361 /** The Parameter type. */
2362 typedef typename DistStor::Params Params;
2363
2364 public:
2365 /**
2366 * Set the parameters of this distribution. @sa DistStor::Params
2367 * @param min The minimum value of the distribution.
2368 * @param max The maximum value of the distribution.
2369 * @param bkt The number of values in each bucket.
2370 * @return A reference to this distribution.
2371 */
2372 Distribution &init(Counter min, Counter max, Counter bkt) {
2373 this->params.min = min;
2374 this->params.max = max;
2375 this->params.bucket_size = bkt;
2376 this->params.size = (int)rint((max - min) / bkt + 1.0);
2377 this->bin.init(this->params);
2378 this->setInit();
2379
2380 return *this;
2381 }
2382};
2383
2384/**
2385 * Calculates the mean and variance of all the samples.
2386 * @sa Stat, DistBase, FancyStor
2387 */
2388template <class Bin = DefaultBin>
2389class StandardDeviation
2390 : public Wrap<StandardDeviation<Bin>,
2391 DistBase<FancyStor, Bin>,
2392 DistStatData>
2393{
2394 public:
2395 /** The base implementation */
2396 typedef DistBase<DistStor, Bin> Base;
2397 /** The parameter type. */
2398 typedef typename DistStor::Params Params;
2399
2400 public:
2401 /**
2402 * Construct and initialize this distribution.
2403 */
2404 StandardDeviation() {
2405 this->bin.init(this->params);
2406 this->setInit();
2407 }
2408};
2409
2410/**
2411 * Calculates the per cycle mean and variance of the samples.
2412 * @sa Stat, DistBase, AvgFancy
2413 */
2414template <class Bin = DefaultBin>
2415class AverageDeviation
2416 : public Wrap<AverageDeviation<Bin>,
2417 DistBase<AvgFancy, Bin>,
2418 DistStatData>
2419{
2420 public:
2421 /** The base implementation */
2422 typedef DistBase<DistStor, Bin> Base;
2423 /** The parameter type. */
2424 typedef typename DistStor::Params Params;
2425
2426 public:
2427 /**
2428 * Construct and initialize this distribution.
2429 */
2430 AverageDeviation()
2431 {
2432 this->bin.init(this->params);
2433 this->setInit();
2434 }
2435};
2436
2437/**
2438 * A vector of distributions.
2439 * @sa Stat, VectorDistBase, DistStor
2440 */
2441template <class Bin = DefaultBin>
2442class VectorDistribution
2443 : public WrapVec<VectorDistribution<Bin>,
2444 VectorDistBase<DistStor, Bin>,
2445 VectorDistStatData>
2446{
2447 public:
2448 /** The base implementation */
2449 typedef VectorDistBase<DistStor, Bin> Base;
2450 /** The parameter type. */
2451 typedef typename DistStor::Params Params;
2452
2453 public:
2454 /**
2455 * Initialize storage and parameters for this distribution.
2456 * @param size The size of the vector (the number of distributions).
2457 * @param min The minimum value of the distribution.
2458 * @param max The maximum value of the distribution.
2459 * @param bkt The number of values in each bucket.
2460 * @return A reference to this distribution.
2461 */
2462 VectorDistribution &init(int size, Counter min, Counter max, Counter bkt) {
2463 this->params.min = min;
2464 this->params.max = max;
2465 this->params.bucket_size = bkt;
2466 this->params.size = (int)rint((max - min) / bkt + 1.0);
2467 this->bin.init(size, this->params);
2468 this->setInit();
2469
2470 return *this;
2471 }
2472};
2473
2474/**
2475 * This is a vector of StandardDeviation stats.
2476 * @sa Stat, VectorDistBase, FancyStor
2477 */
2478template <class Bin = DefaultBin>
2479class VectorStandardDeviation
2480 : public WrapVec<VectorStandardDeviation<Bin>,
2481 VectorDistBase<FancyStor, Bin>,
2482 VectorDistStatData>
2483{
2484 public:
2485 /** The base implementation */
2486 typedef VectorDistBase<FancyStor, Bin> Base;
2487 /** The parameter type. */
2488 typedef typename DistStor::Params Params;
2489
2490 public:
2491 /**
2492 * Initialize storage for this distribution.
2493 * @param size The size of the vector.
2494 * @return A reference to this distribution.
2495 */
2496 VectorStandardDeviation &init(int size) {
2497 this->bin.init(size, this->params);
2498 this->setInit();
2499
2500 return *this;
2501 }
2502};
2503
2504/**
2505 * This is a vector of AverageDeviation stats.
2506 * @sa Stat, VectorDistBase, AvgFancy
2507 */
2508template <class Bin = DefaultBin>
2509class VectorAverageDeviation
2510 : public WrapVec<VectorAverageDeviation<Bin>,
2511 VectorDistBase<AvgFancy, Bin>,
2512 VectorDistStatData>
2513{
2514 public:
2515 /** The base implementation */
2516 typedef VectorDistBase<AvgFancy, Bin> Base;
2517 /** The parameter type. */
2518 typedef typename DistStor::Params Params;
2519
2520 public:
2521 /**
2522 * Initialize storage for this distribution.
2523 * @param size The size of the vector.
2524 * @return A reference to this distribution.
2525 */
2526 VectorAverageDeviation &init(int size) {
2527 this->bin.init(size, this->params);
2528 this->setInit();
2529
2530 return *this;
2531 }
2532};
2533
2534/**
2535 * A formula for statistics that is calculated when printed. A formula is
2536 * stored as a tree of Nodes that represent the equation to calculate.
2537 * @sa Stat, ScalarStat, VectorStat, Node, Temp
--- 27 unchanged lines hidden (view full) ---
2565 */
2566 Result total() const;
2567
2568 /**
2569 * Return the number of elements in the tree.
2570 */
2571 size_t size() const;
2572
2573 /**
2574 * Return true if Formula is binned. i.e. any of its children
2575 * nodes are binned
2576 * @return True if Formula is binned.
2577 */
2578 bool binned() const;
2579
2580 bool check() const { return true; }
2581
2582 /**
2583 * Formulas don't need to be reset
2584 */
2585 void reset();
2586
2587 /**
--- 22 unchanged lines hidden (view full) ---
2610 protected:
2611 Stat &s;
2612 mutable VResult vec;
2613 mutable VCounter cvec;
2614
2615 public:
2616 FormulaStatData(Stat &stat) : s(stat) {}
2617
2618 virtual bool binned() const { return s.binned(); }
2619 virtual bool zero() const { return s.zero(); }
2620 virtual void reset() { s.reset(); }
2621
2622 virtual size_t size() const { return s.size(); }
2623 virtual const VResult &result() const
2624 {
2625 s.result(vec);
2626 return vec;
--- 50 unchanged lines hidden (view full) ---
2677 mutable VResult vec;
2678
2679 public:
2680 FormulaNode(const Formula &f) : formula(f) {}
2681
2682 virtual size_t size() const { return formula.size(); }
2683 virtual const VResult &result() const { formula.result(vec); return vec; }
2684 virtual Result total() const { return formula.total(); }
2685 virtual bool binned() const { return formula.binned(); }
2686
2687 virtual std::string str() const { return formula.str(); }
2688};
2689
2690/**
2691 * Helper class to construct formula node trees.
2692 */
2693class Temp
--- 17 unchanged lines hidden (view full) ---
2711 */
2712 operator NodePtr&() { return node;}
2713
2714 public:
2715 /**
2716 * Create a new ScalarStatNode.
2717 * @param s The ScalarStat to place in a node.
2718 */
2719 template <class Bin>
2720 Temp(const Scalar<Bin> &s)
2721 : node(new ScalarStatNode(s.statData())) { }
2722
2723 /**
2724 * Create a new ScalarStatNode.
2725 * @param s The ScalarStat to place in a node.
2726 */
2727 Temp(const Value &s)
2728 : node(new ScalarStatNode(s.statData())) { }
2729
2730 /**
2731 * Create a new ScalarStatNode.
2732 * @param s The ScalarStat to place in a node.
2733 */
2734 template <class Bin>
2735 Temp(const Average<Bin> &s)
2736 : node(new ScalarStatNode(s.statData())) { }
2737
2738 /**
2739 * Create a new VectorStatNode.
2740 * @param s The VectorStat to place in a node.
2741 */
2742 template <class Bin>
2743 Temp(const Vector<Bin> &s)
2744 : node(new VectorStatNode(s.statData())) { }
2745
2746 /**
2747 *
2748 */
2749 Temp(const Formula &f)
2750 : node(new FormulaNode(f)) { }
2751
2752 /**
2753 * Create a new ScalarProxyNode.
2754 * @param p The ScalarProxy to place in a node.
2755 */
2756 template <class Storage, class Bin>
2757 Temp(const ScalarProxy<Storage, Bin> &p)
2758 : node(new ScalarProxyNode<Storage, Bin>(p)) { }
2759
2760 /**
2761 * Create a ConstNode
2762 * @param value The value of the const node.
2763 */
2764 Temp(signed char value)
2765 : node(new ConstNode<signed char>(value)) {}
2766
--- 133 unchanged lines hidden ---
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;
--- 46 unchanged lines hidden (view full) ---
55#include <iosfwd>
56#include <string>
57#include <vector>
58
59#include "base/cprintf.hh"
60#include "base/intmath.hh"
61#include "base/refcnt.hh"
62#include "base/str.hh"
63#include "base/stats/bin.hh"
64#include "base/stats/flags.hh"
65#include "base/stats/visit.hh"
66#include "base/stats/types.hh"
67#include "config/stats_binning.hh"
68#include "sim/host.hh"
69
70class Callback;
71
72/** The current simulated cycle. */
73extern Tick curTick;
74
75/* A namespace for all of the Statistics */
--- 22 unchanged lines hidden (view full) ---
98 * Can be used externally for lookups as well as for debugging.
99 */
100 int id;
101
102 StatData();
103 virtual ~StatData();
104
105 /**
106 * @return true if the stat is binned.
107 */
108 virtual bool binned() const = 0;
109
110 /**
111 * Reset the corresponding stat to the default state.
112 */
113 virtual void reset() = 0;
114
115 /**
116 * @return true if this stat has a value and satisfies its
117 * requirement as a prereq
118 */
--- 36 unchanged lines hidden (view full) ---
155class ScalarStatData : public ScalarData
156{
157 protected:
158 Stat &s;
159
160 public:
161 ScalarStatData(Stat &stat) : s(stat) {}
162
163 virtual bool binned() const { return s.binned(); }
164 virtual bool check() const { return s.check(); }
165 virtual Counter value() const { return s.value(); }
166 virtual Result result() const { return s.result(); }
167 virtual Result total() const { return s.total(); }
168 virtual void reset() { s.reset(); }
169 virtual bool zero() const { return s.zero(); }
170};
171
--- 26 unchanged lines hidden (view full) ---
198 protected:
199 Stat &s;
200 mutable VCounter cvec;
201 mutable VResult rvec;
202
203 public:
204 VectorStatData(Stat &stat) : s(stat) {}
205
206 virtual bool binned() const { return s.binned(); }
207 virtual bool check() const { return s.check(); }
208 virtual bool zero() const { return s.zero(); }
209 virtual void reset() { s.reset(); }
210
211 virtual size_t size() const { return s.size(); }
212 virtual VCounter &value() const
213 {
214 s.value(cvec);
--- 41 unchanged lines hidden (view full) ---
256class DistStatData : public DistData
257{
258 protected:
259 Stat &s;
260
261 public:
262 DistStatData(Stat &stat) : s(stat) {}
263
264 virtual bool binned() const { return s.binned(); }
265 virtual bool check() const { return s.check(); }
266 virtual void reset() { s.reset(); }
267 virtual bool zero() const { return s.zero(); }
268 virtual void visit(Visit &visitor)
269 {
270 s.update(this);
271 visitor.visit(*this);
272 }
--- 22 unchanged lines hidden (view full) ---
295 }
296};
297
298template <class Stat>
299class VectorDistStatData : public VectorDistData
300{
301 protected:
302 Stat &s;
303 typedef typename Stat::bin_t bin_t;
304
305 public:
306 VectorDistStatData(Stat &stat) : s(stat) {}
307
308 virtual bool binned() const { return bin_t::binned; }
309 virtual bool check() const { return s.check(); }
310 virtual void reset() { s.reset(); }
311 virtual size_t size() const { return s.size(); }
312 virtual bool zero() const { return s.zero(); }
313 virtual void visit(Visit &visitor)
314 {
315 update();
316 s.update(this);
--- 20 unchanged lines hidden (view full) ---
337 }
338};
339
340template <class Stat>
341class Vector2dStatData : public Vector2dData
342{
343 protected:
344 Stat &s;
345 typedef typename Stat::bin_t bin_t;
346
347 public:
348 Vector2dStatData(Stat &stat) : s(stat) {}
349
350 virtual bool binned() const { return bin_t::binned; }
351 virtual bool check() const { return s.check(); }
352 virtual void reset() { s.reset(); }
353 virtual bool zero() const { return s.zero(); }
354 virtual void visit(Visit &visitor)
355 {
356 update();
357 s.update(this);
358 visitor.visit(*this);
359 }
360};
361
362
363class DataAccess
364{
365 protected:
366 StatData *find() const;
367 void map(StatData *data);
368
369 StatData *statData();
370 const StatData *statData() const;
--- 239 unchanged lines hidden (view full) ---
610};
611
612/**
613 * Templatized storage and interface to a per-cycle average stat. This keeps
614 * a current count and updates a total (count * cycles) when this count
615 * changes. This allows the quick calculation of a per cycle count of the item
616 * being watched. This is good for keeping track of residencies in structures
617 * among other things.
618 * @todo add lateny to the stat and fix binning.
619 */
620struct AvgStor
621{
622 public:
623 /** The paramaters for this storage type */
624 struct Params
625 {
626 /**
627 * The current count. We stash this here because the current
628 * value is not a binned value.
629 */
630 Counter current;
631 };
632
633 private:
634 /** The total count for all cycles. */
635 mutable Result total;
636 /** The cycle that current last changed. */
637 mutable Tick last;
638
639 public:
640 /**
641 * Build and initializes this stat storage.
642 */
643 AvgStor(Params &p) : total(0), last(0) { p.current = Counter(); }
644
645 /**
646 * Set the current count to the one provided, update the total and last
647 * set values.
648 * @param val The new count.
649 * @param p The parameters for this storage.
650 */
651 void set(Counter val, Params &p) {
652 total += p.current * (curTick - last);
653 last = curTick;
654 p.current = val;
655 }
656
657 /**
658 * Increment the current count by the provided value, calls set.
659 * @param val The amount to increment.
660 * @param p The parameters for this storage.
661 */
662 void inc(Counter val, Params &p) { set(p.current + val, p); }
663
664 /**
665 * Deccrement the current count by the provided value, calls set.
666 * @param val The amount to decrement.
667 * @param p The parameters for this storage.
668 */
669 void dec(Counter val, Params &p) { set(p.current - val, p); }
670
671 /**
672 * Return the current count.
673 * @param p The parameters for this storage.
674 * @return The current count.
675 */
676 Counter value(const Params &p) const { return p.current; }
677
678 /**
679 * Return the current average.
680 * @param p The parameters for this storage.
681 * @return The current average.
682 */
683 Result result(const Params &p) const
684 {
685 total += p.current * (curTick - last);
686 last = curTick;
687 return (Result)(total + p.current) / (Result)(curTick + 1);
688 }
689
690 /**
691 * Reset stat value to default
692 */
693 void reset()
694 {
695 total = 0;
696 last = curTick;
697 }
698
699 /**
700 * @return true if zero value
701 */
702 bool zero() const { return total == 0.0; }
703};
704
705/**
706 * Implementation of a scalar stat. The type of stat is determined by the
707 * Storage template. The storage for this stat is held within the Bin class.
708 * This allows for breaking down statistics across multiple bins easily.
709 */
710template <class Storage, class Bin>
711class ScalarBase : public DataAccess
712{
713 public:
714 /** Define the params of the storage class. */
715 typedef typename Storage::Params params_t;
716 /** Define the bin type. */
717 typedef typename Bin::template Bin<Storage> bin_t;
718
719 protected:
720 /** The bin of this stat. */
721 bin_t bin;
722 /** The parameters for this stat. */
723 params_t params;
724
725 protected:
726 /**
727 * Retrieve the storage from the bin.
728 * @return The storage object for this stat.
729 */
730 Storage *data() { return bin.data(params); }
731 /**
732 * Retrieve a const pointer to the storage from the bin.
733 * @return A const pointer to the storage object for this stat.
734 */
735 const Storage *data() const
736 {
737 bin_t *_bin = const_cast<bin_t *>(&bin);
738 params_t *_params = const_cast<params_t *>(¶ms);
739 return _bin->data(*_params);
740 }
741
742 public:
743 /**
744 * Return the current value of this stat as its base type.
745 * @return The current value.
746 */
747 Counter value() const { return data()->value(params); }
748
749 public:
750 /**
751 * Create and initialize this stat, register it with the database.
752 */
753 ScalarBase()
754 {
755 bin.init(params);
756 }
757
758 public:
759 // Common operators for stats
760 /**
761 * Increment the stat by 1. This calls the associated storage object inc
762 * function.
763 */
764 void operator++() { data()->inc(1, params); }
--- 32 unchanged lines hidden (view full) ---
797 template <typename U>
798 void operator-=(const U &v) { data()->dec(v, params); }
799
800 /**
801 * Return the number of elements, always 1 for a scalar.
802 * @return 1.
803 */
804 size_t size() const { return 1; }
805 /**
806 * Return true if stat is binned.
807 *@return True is stat is binned.
808 */
809 bool binned() const { return bin_t::binned; }
810
811 bool check() const { return bin.initialized(); }
812
813 /**
814 * Reset stat value to default
815 */
816 void reset() { bin.reset(); }
817
818 Counter value() { return data()->value(params); }
819
820 Result result() { return data()->result(params); }
821
822 Result total() { return result(); }
823
824 bool zero() { return result() == 0.0; }
825
826};
827
828class ProxyData : public ScalarData
829{
830 public:
831 virtual void visit(Visit &visitor) { visitor.visit(*this); }
832 virtual bool binned() const { return false; }
833 virtual std::string str() const { return to_string(value()); }
834 virtual size_t size() const { return 1; }
835 virtual bool zero() const { return value() == 0; }
836 virtual bool check() const { return true; }
837 virtual void reset() { }
838};
839
840template <class T>
--- 45 unchanged lines hidden (view full) ---
886 setInit();
887 }
888
889 Counter value() { return proxy->value(); }
890 Result result() const { return proxy->result(); }
891 Result total() const { return proxy->total(); };
892 size_t size() const { return proxy->size(); }
893
894 bool binned() const { return proxy->binned(); }
895 std::string str() const { return proxy->str(); }
896 bool zero() const { return proxy->zero(); }
897 bool check() const { return proxy != NULL; }
898 void reset() { }
899};
900
901//////////////////////////////////////////////////////////////////////
902//
903// Vector Statistics
904//
905//////////////////////////////////////////////////////////////////////
906template <class Storage, class Bin>
907class ScalarProxy;
908
909/**
910 * Implementation of a vector of stats. The type of stat is determined by the
911 * Storage class. @sa ScalarBase
912 */
913template <class Storage, class Bin>
914class VectorBase : public DataAccess
915{
916 public:
917 /** Define the params of the storage class. */
918 typedef typename Storage::Params params_t;
919 /** Define the bin type. */
920 typedef typename Bin::template VectorBin<Storage> bin_t;
921
922 protected:
923 /** The bin of this stat. */
924 bin_t bin;
925 /** The parameters for this stat. */
926 params_t params;
927
928 protected:
929 /**
930 * Retrieve the storage from the bin for the given index.
931 * @param index The vector index to access.
932 * @return The storage object at the given index.
933 */
934 Storage *data(int index) { return bin.data(index, params); }
935 /**
936 * Retrieve a const pointer to the storage from the bin
937 * for the given index.
938 * @param index The vector index to access.
939 * @return A const pointer to the storage object at the given index.
940 */
941 const Storage *data(int index) const
942 {
943 bin_t *_bin = const_cast<bin_t *>(&bin);
944 params_t *_params = const_cast<params_t *>(¶ms);
945 return _bin->data(index, *_params);
946 }
947
948 public:
949 void value(VCounter &vec) const
950 {
951 vec.resize(size());
952 for (int i = 0; i < size(); ++i)
953 vec[i] = data(i)->value(params);
954 }
955
956 /**
957 * Copy the values to a local vector and return a reference to it.
958 * @return A reference to a vector of the stat values.
959 */
960 void result(VResult &vec) const
961 {
962 vec.resize(size());
963 for (int i = 0; i < size(); ++i)
964 vec[i] = data(i)->result(params);
965 }
966
967 /**
968 * @return True is stat is binned.
969 */
970 bool binned() const { return bin_t::binned; }
971
972 /**
973 * Return a total of all entries in this vector.
974 * @return The total of all vector entries.
975 */
976 Result total() const {
977 Result total = 0.0;
978 for (int i = 0; i < size(); ++i)
979 total += data(i)->result(params);
980 return total;
981 }
982
983 /**
984 * @return the number of elements in this vector.
985 */
986 size_t size() const { return bin.size(); }
987
988 bool zero() const
989 {
990 for (int i = 0; i < size(); ++i)
991 if (data(i)->zero())
992 return true;
993 return false;
994 }
995
996 bool check() const { return bin.initialized(); }
997 void reset() { bin.reset(); }
998
999 public:
1000 VectorBase() {}
1001
1002 /** Friend this class with the associated scalar proxy. */
1003 friend class ScalarProxy<Storage, Bin>;
1004
1005 /**
1006 * Return a reference (ScalarProxy) to the stat at the given index.
1007 * @param index The vector index to access.
1008 * @return A reference of the stat.
1009 */
1010 ScalarProxy<Storage, Bin> operator[](int index);
1011
1012 void update(StatData *data) {}
1013};
1014
1015const StatData * getStatData(const void *stat);
1016
1017/**
1018 * A proxy class to access the stat at a given index in a VectorBase stat.
1019 * Behaves like a ScalarBase.
1020 */
1021template <class Storage, class Bin>
1022class ScalarProxy
1023{
1024 public:
1025 /** Define the params of the storage class. */
1026 typedef typename Storage::Params params_t;
1027 /** Define the bin type. */
1028 typedef typename Bin::template VectorBin<Storage> bin_t;
1029
1030 private:
1031 /** Pointer to the bin in the parent VectorBase. */
1032 bin_t *bin;
1033 /** Pointer to the params in the parent VectorBase. */
1034 params_t *params;
1035 /** The index to access in the parent VectorBase. */
1036 int index;
1037 /** Keep a pointer to the original stat so was can get data */
1038 void *stat;
1039
1040 protected:
1041 /**
1042 * Retrieve the storage from the bin.
1043 * @return The storage from the bin for this stat.
1044 */
1045 Storage *data() { return bin->data(index, *params); }
1046 /**
1047 * Retrieve a const pointer to the storage from the bin.
1048 * @return A const pointer to the storage for this stat.
1049 */
1050 const Storage *data() const
1051 {
1052 bin_t *_bin = const_cast<bin_t *>(bin);
1053 params_t *_params = const_cast<params_t *>(params);
1054 return _bin->data(index, *_params);
1055 }
1056
1057 public:
1058 /**
1059 * Return the current value of this stat as its base type.
1060 * @return The current value.
1061 */
1062 Counter value() const { return data()->value(*params); }
1063
1064 /**
1065 * Return the current value of this statas a result type.
1066 * @return The current value.
1067 */
1068 Result result() const { return data()->result(*params); }
1069
1070 public:
1071 /**
1072 * Create and initialize this proxy, do not register it with the database.
1073 * @param b The bin to use.
1074 * @param p The params to use.
1075 * @param i The index to access.
1076 */
1077 ScalarProxy(bin_t &b, params_t &p, int i, void *s)
1078 : bin(&b), params(&p), index(i), stat(s) {}
1079 /**
1080 * Create a copy of the provided ScalarProxy.
1081 * @param sp The proxy to copy.
1082 */
1083 ScalarProxy(const ScalarProxy &sp)
1084 : bin(sp.bin), params(sp.params), index(sp.index), stat(sp.stat) {}
1085 /**
1086 * Set this proxy equal to the provided one.
1087 * @param sp The proxy to copy.
1088 * @return A reference to this proxy.
1089 */
1090 const ScalarProxy &operator=(const ScalarProxy &sp) {
1091 bin = sp.bin;
1092 params = sp.params;
1093 index = sp.index;
1094 stat = sp.stat;
1095 return *this;
1096 }
1097
1098 public:
1099 // Common operators for stats
1100 /**
1101 * Increment the stat by 1. This calls the associated storage object inc
1102 * function.
1103 */
1104 void operator++() { data()->inc(1, *params); }
1105 /**
1106 * Decrement the stat by 1. This calls the associated storage object dec
1107 * function.
1108 */
1109 void operator--() { data()->dec(1, *params); }
1110
1111 /** Increment the stat by 1. */
1112 void operator++(int) { ++*this; }
1113 /** Decrement the stat by 1. */
1114 void operator--(int) { --*this; }
1115
1116 /**
1117 * Set the data value to the given value. This calls the associated storage
1118 * object set function.
1119 * @param v The new value.
1120 */
1121 template <typename U>
1122 void operator=(const U &v) { data()->set(v, *params); }
1123
1124 /**
1125 * Increment the stat by the given value. This calls the associated
1126 * storage object inc function.
1127 * @param v The value to add.
1128 */
1129 template <typename U>
1130 void operator+=(const U &v) { data()->inc(v, *params); }
1131
1132 /**
1133 * Decrement the stat by the given value. This calls the associated
1134 * storage object dec function.
1135 * @param v The value to substract.
1136 */
1137 template <typename U>
1138 void operator-=(const U &v) { data()->dec(v, *params); }
1139
1140 /**
1141 * Return the number of elements, always 1 for a scalar.
1142 * @return 1.
1143 */
1144 size_t size() const { return 1; }
1145
1146 /**
1147 * Return true if stat is binned.
1148 *@return false since Proxies aren't printed/binned
1149 */
1150 bool binned() const { return false; }
1151
1152 /**
1153 * This stat has no state. Nothing to reset
1154 */
1155 void reset() { }
1156
1157 public:
1158 const StatData *statData() const { return getStatData(stat); }
1159 std::string str() const
1160 {
1161 return csprintf("%s[%d]", this->statData()->name, index);
1162
1163 }
1164};
1165
1166template <class Storage, class Bin>
1167inline ScalarProxy<Storage, Bin>
1168VectorBase<Storage, Bin>::operator[](int index)
1169{
1170 assert (index >= 0 && index < size());
1171 return ScalarProxy<Storage, Bin>(bin, params, index, this);
1172}
1173
1174template <class Storage, class Bin>
1175class VectorProxy;
1176
1177template <class Storage, class Bin>
1178class Vector2dBase : public DataAccess
1179{
1180 public:
1181 typedef typename Storage::Params params_t;
1182 typedef typename Bin::template VectorBin<Storage> bin_t;
1183
1184 protected:
1185 size_t x;
1186 size_t y;
1187 bin_t bin;
1188 params_t params;
1189
1190 protected:
1191 Storage *data(int index) { return bin.data(index, params); }
1192 const Storage *data(int index) const
1193 {
1194 bin_t *_bin = const_cast<bin_t *>(&bin);
1195 params_t *_params = const_cast<params_t *>(¶ms);
1196 return _bin->data(index, *_params);
1197 }
1198
1199 public:
1200 Vector2dBase() {}
1201
1202 void update(Vector2dData *data)
1203 {
1204 int size = this->size();
1205 data->cvec.resize(size);
1206 for (int i = 0; i < size; ++i)
1207 data->cvec[i] = this->data(i)->value(params);
1208 }
1209
1210 std::string ysubname(int i) const { return (*this->y_subnames)[i]; }
1211
1212 friend class VectorProxy<Storage, Bin>;
1213 VectorProxy<Storage, Bin> operator[](int index);
1214
1215 size_t size() const { return bin.size(); }
1216 bool zero() const { return data(0)->value(params) == 0.0; }
1217
1218 /**
1219 * Reset stat value to default
1220 */
1221 void reset() { bin.reset(); }
1222
1223 bool check() { return bin.initialized(); }
1224};
1225
1226template <class Storage, class Bin>
1227class VectorProxy
1228{
1229 public:
1230 typedef typename Storage::Params params_t;
1231 typedef typename Bin::template VectorBin<Storage> bin_t;
1232
1233 private:
1234 bin_t *bin;
1235 params_t *params;
1236 int offset;
1237 int len;
1238 void *stat;
1239
1240 private:
1241 mutable VResult *vec;
1242
1243 Storage *data(int index) {
1244 assert(index < len);
1245 return bin->data(offset + index, *params);
1246 }
1247
1248 const Storage *data(int index) const {
1249 bin_t *_bin = const_cast<bin_t *>(bin);
1250 params_t *_params = const_cast<params_t *>(params);
1251 return _bin->data(offset + index, *_params);
1252 }
1253
1254 public:
1255 const VResult &result() const {
1256 if (vec)
1257 vec->resize(size());
1258 else
1259 vec = new VResult(size());
1260
1261 for (int i = 0; i < size(); ++i)
1262 (*vec)[i] = data(i)->result(*params);
1263
1264 return *vec;
1265 }
1266
1267 Result total() const {
1268 Result total = 0.0;
1269 for (int i = 0; i < size(); ++i)
1270 total += data(i)->result(*params);
1271 return total;
1272 }
1273
1274 public:
1275 VectorProxy(bin_t &b, params_t &p, int o, int l, void *s)
1276 : bin(&b), params(&p), offset(o), len(l), stat(s), vec(NULL)
1277 {
1278 }
1279
1280 VectorProxy(const VectorProxy &sp)
1281 : bin(sp.bin), params(sp.params), offset(sp.offset), len(sp.len),
1282 stat(sp.stat), vec(NULL)
1283 {
1284 }
1285
1286 ~VectorProxy()
1287 {
1288 if (vec)
1289 delete vec;
1290 }
1291
1292 const VectorProxy &operator=(const VectorProxy &sp)
1293 {
1294 bin = sp.bin;
1295 params = sp.params;
1296 offset = sp.offset;
1297 len = sp.len;
1298 stat = sp.stat;
1299 if (vec)
1300 delete vec;
1301 vec = NULL;
1302 return *this;
1303 }
1304
1305 ScalarProxy<Storage, Bin> operator[](int index)
1306 {
1307 assert (index >= 0 && index < size());
1308 return ScalarProxy<Storage, Bin>(*bin, *params, offset + index, stat);
1309 }
1310
1311 size_t size() const { return len; }
1312
1313 /**
1314 * Return true if stat is binned.
1315 *@return false since Proxies aren't printed/binned
1316 */
1317 bool binned() const { return false; }
1318
1319 /**
1320 * This stat has no state. Nothing to reset.
1321 */
1322 void reset() { }
1323};
1324
1325template <class Storage, class Bin>
1326inline VectorProxy<Storage, Bin>
1327Vector2dBase<Storage, Bin>::operator[](int index)
1328{
1329 int offset = index * y;
1330 assert (index >= 0 && offset < size());
1331 return VectorProxy<Storage, Bin>(bin, params, offset, y, this);
1332}
1333
1334//////////////////////////////////////////////////////////////////////
1335//
1336// Non formula statistics
1337//
1338//////////////////////////////////////////////////////////////////////
1339
1340/**
1341 * Templatized storage and interface for a distrbution stat.
--- 29 unchanged lines hidden (view full) ---
1371 /** The sum of squares. */
1372 Counter squares;
1373 /** The number of samples. */
1374 Counter samples;
1375 /** Counter for each bucket. */
1376 VCounter cvec;
1377
1378 public:
1379 /**
1380 * Construct this storage with the supplied params.
1381 * @param params The parameters.
1382 */
1383 DistStor(const Params ¶ms)
1384 : min_val(INT_MAX), max_val(INT_MIN), underflow(Counter()),
1385 overflow(Counter()), sum(Counter()), squares(Counter()),
1386 samples(Counter()), cvec(params.size)
1387 {
1388 reset();
1389 }
1390
1391 /**
1392 * Add a value to the distribution for the given number of times.
1393 * @param val The value to add.
1394 * @param number The number of times to add the value.
--- 218 unchanged lines hidden (view full) ---
1613 squares = Counter();
1614 }
1615};
1616
1617/**
1618 * Implementation of a distribution stat. The type of distribution is
1619 * determined by the Storage template. @sa ScalarBase
1620 */
1621template <class Storage, class Bin>
1622class DistBase : public DataAccess
1623{
1624 public:
1625 /** Define the params of the storage class. */
1626 typedef typename Storage::Params params_t;
1627 /** Define the bin type. */
1628 typedef typename Bin::template Bin<Storage> bin_t;
1629
1630 protected:
1631 /** The bin of this stat. */
1632 bin_t bin;
1633 /** The parameters for this stat. */
1634 params_t params;
1635
1636 protected:
1637 /**
1638 * Retrieve the storage from the bin.
1639 * @return The storage object for this stat.
1640 */
1641 Storage *data() { return bin.data(params); }
1642 /**
1643 * Retrieve a const pointer to the storage from the bin.
1644 * @return A const pointer to the storage object for this stat.
1645 */
1646 const Storage *data() const
1647 {
1648 bin_t *_bin = const_cast<bin_t *>(&bin);
1649 params_t *_params = const_cast<params_t *>(¶ms);
1650 return _bin->data(*_params);
1651 }
1652
1653 public:
1654 DistBase() { }
1655
1656 /**
1657 * Add a value to the distribtion n times. Calls sample on the storage
1658 * class.
1659 * @param v The value to add.
1660 * @param n The number of times to add it, defaults to 1.
--- 12 unchanged lines hidden (view full) ---
1673 */
1674 bool zero() const { return data()->zero(params); }
1675
1676 void update(DistData *base)
1677 {
1678 base->data.fancy = Storage::fancy;
1679 data()->update(&(base->data), params);
1680 }
1681 /**
1682 * @return True is stat is binned.
1683 */
1684 bool binned() const { return bin_t::binned; }
1685 /**
1686 * Reset stat value to default
1687 */
1688 void reset()
1689 {
1690 bin.reset();
1691 }
1692
1693 bool check() { return bin.initialized(); }
1694};
1695
1696template <class Storage, class Bin>
1697class DistProxy;
1698
1699template <class Storage, class Bin>
1700class VectorDistBase : public DataAccess
1701{
1702 public:
1703 typedef typename Storage::Params params_t;
1704 typedef typename Bin::template VectorBin<Storage> bin_t;
1705
1706 protected:
1707 bin_t bin;
1708 params_t params;
1709
1710 protected:
1711 Storage *data(int index) { return bin.data(index, params); }
1712 const Storage *data(int index) const
1713 {
1714 bin_t *_bin = const_cast<bin_t *>(&bin);
1715 params_t *_params = const_cast<params_t *>(¶ms);
1716 return _bin->data(index, *_params);
1717 }
1718
1719 public:
1720 VectorDistBase() {}
1721
1722 friend class DistProxy<Storage, Bin>;
1723 DistProxy<Storage, Bin> operator[](int index);
1724 const DistProxy<Storage, Bin> operator[](int index) const;
1725
1726 size_t size() const { return bin.size(); }
1727 bool zero() const { return false; }
1728 /**
1729 * Return true if stat is binned.
1730 *@return True is stat is binned.
1731 */
1732 bool binned() const { return bin_t::binned; }
1733 /**
1734 * Reset stat value to default
1735 */
1736 void reset() { bin.reset(); }
1737
1738 bool check() { return bin.initialized(); }
1739 void update(VectorDistData *base)
1740 {
1741 int size = this->size();
1742 base->data.resize(size);
1743 for (int i = 0; i < size; ++i) {
1744 base->data[i].fancy = Storage::fancy;
1745 data(i)->update(&(base->data[i]), params);
1746 }
1747 }
1748};
1749
1750template <class Storage, class Bin>
1751class DistProxy
1752{
1753 public:
1754 typedef typename Storage::Params params_t;
1755 typedef typename Bin::template Bin<Storage> bin_t;
1756 typedef VectorDistBase<Storage, Bin> base_t;
1757
1758 private:
1759 union {
1760 base_t *stat;
1761 const base_t *cstat;
1762 };
1763 int index;
1764
1765 protected:
1766 Storage *data() { return stat->data(index); }
1767 const Storage *data() const { return cstat->data(index); }
1768
1769 public:
1770 DistProxy(const VectorDistBase<Storage, Bin> &s, int i)
1771 : cstat(&s), index(i) {}
1772 DistProxy(const DistProxy &sp)
1773 : cstat(sp.cstat), index(sp.index) {}
1774 const DistProxy &operator=(const DistProxy &sp) {
1775 cstat = sp.cstat; index = sp.index; return *this;
1776 }
1777
1778 public:
1779 template <typename U>
1780 void sample(const U &v, int n = 1) { data()->sample(v, n, cstat->params); }
1781
1782 size_t size() const { return 1; }
1783 bool zero() const { return data()->zero(cstat->params); }
1784 /**
1785 * Return true if stat is binned.
1786 *@return false since Proxies are not binned/printed.
1787 */
1788 bool binned() const { return false; }
1789 /**
1790 * Proxy has no state. Nothing to reset.
1791 */
1792 void reset() { }
1793};
1794
1795template <class Storage, class Bin>
1796inline DistProxy<Storage, Bin>
1797VectorDistBase<Storage, Bin>::operator[](int index)
1798{
1799 assert (index >= 0 && index < size());
1800 return DistProxy<Storage, Bin>(*this, index);
1801}
1802
1803template <class Storage, class Bin>
1804inline const DistProxy<Storage, Bin>
1805VectorDistBase<Storage, Bin>::operator[](int index) const
1806{
1807 assert (index >= 0 && index < size());
1808 return DistProxy<Storage, Bin>(*this, index);
1809}
1810
1811#if 0
1812template <class Storage, class Bin>
1813Result
1814VectorDistBase<Storage, Bin>::total(int index) const
1815{
1816 int total = 0;
1817 for (int i=0; i < x_size(); ++i) {
1818 total += data(i)->result(*params);
1819 }
1820}
1821#endif
1822
1823//////////////////////////////////////////////////////////////////////
1824//
1825// Formula Details
1826//
--- 16 unchanged lines hidden (view full) ---
1843 * @return The result vector of this subtree.
1844 */
1845 virtual const VResult &result() const = 0;
1846 /**
1847 * Return the total of the result vector.
1848 * @return The total of the result vector.
1849 */
1850 virtual Result total() const = 0;
1851 /**
1852 * Return true if stat is binned.
1853 *@return True is stat is binned.
1854 */
1855 virtual bool binned() const = 0;
1856
1857 /**
1858 *
1859 */
1860 virtual std::string str() const = 0;
1861};
1862
1863/** Reference counting pointer to a function Node. */
--- 10 unchanged lines hidden (view full) ---
1874 virtual const VResult &result() const
1875 {
1876 vresult[0] = data->result();
1877 return vresult;
1878 }
1879 virtual Result total() const { return data->result(); };
1880
1881 virtual size_t size() const { return 1; }
1882 /**
1883 * Return true if stat is binned.
1884 *@return True is stat is binned.
1885 */
1886 virtual bool binned() const { return data->binned(); }
1887
1888 /**
1889 *
1890 */
1891 virtual std::string str() const { return data->name; }
1892};
1893
1894template <class Storage, class Bin>
1895class ScalarProxyNode : public Node
1896{
1897 private:
1898 const ScalarProxy<Storage, Bin> proxy;
1899 mutable VResult vresult;
1900
1901 public:
1902 ScalarProxyNode(const ScalarProxy<Storage, Bin> &p)
1903 : proxy(p), vresult(1) { }
1904 virtual const VResult &result() const
1905 {
1906 vresult[0] = proxy.result();
1907 return vresult;
1908 }
1909 virtual Result total() const { return proxy.result(); };
1910
1911 virtual size_t size() const { return 1; }
1912 /**
1913 * Return true if stat is binned.
1914 *@return True is stat is binned.
1915 */
1916 virtual bool binned() const { return proxy.binned(); }
1917
1918 /**
1919 *
1920 */
1921 virtual std::string str() const { return proxy.str(); }
1922};
1923
1924class VectorStatNode : public Node
1925{
1926 private:
1927 const VectorData *data;
1928
1929 public:
1930 VectorStatNode(const VectorData *d) : data(d) { }
1931 virtual const VResult &result() const { return data->result(); }
1932 virtual Result total() const { return data->total(); };
1933
1934 virtual size_t size() const { return data->size(); }
1935 /**
1936 * Return true if stat is binned.
1937 *@return True is stat is binned.
1938 */
1939 virtual bool binned() const { return data->binned(); }
1940
1941 virtual std::string str() const { return data->name; }
1942};
1943
1944template <class T>
1945class ConstNode : public Node
1946{
1947 private:
1948 VResult vresult;
1949
1950 public:
1951 ConstNode(T s) : vresult(1, (Result)s) {}
1952 const VResult &result() const { return vresult; }
1953 virtual Result total() const { return vresult[0]; };
1954 virtual size_t size() const { return 1; }
1955
1956 /**
1957 * Return true if stat is binned.
1958 *@return False since constants aren't binned.
1959 */
1960 virtual bool binned() const { return false; }
1961
1962 virtual std::string str() const { return to_string(vresult[0]); }
1963};
1964
1965template <class Op>
1966struct OpString;
1967
1968template<>
1969struct OpString<std::plus<Result> >
--- 57 unchanged lines hidden (view full) ---
2027 }
2028
2029 Result total() const {
2030 Op op;
2031 return op(l->total());
2032 }
2033
2034 virtual size_t size() const { return l->size(); }
2035 /**
2036 * Return true if child of node is binned.
2037 *@return True if child of node is binned.
2038 */
2039 virtual bool binned() const { return l->binned(); }
2040
2041 virtual std::string str() const
2042 {
2043 return OpString<Op>::str() + l->str();
2044 }
2045};
2046
2047template <class Op>
--- 50 unchanged lines hidden (view full) ---
2098 return rs;
2099 else if (rs == 1)
2100 return ls;
2101 else {
2102 assert(ls == rs && "Node vector sizes are not equal");
2103 return ls;
2104 }
2105 }
2106 /**
2107 * Return true if any children of node are binned
2108 *@return True if either child of node is binned.
2109 */
2110 virtual bool binned() const { return (l->binned() || r->binned()); }
2111
2112 virtual std::string str() const
2113 {
2114 return csprintf("(%s %s %s)", l->str(), OpString<Op>::str(), r->str());
2115 }
2116};
2117
2118template <class Op>
--- 32 unchanged lines hidden (view full) ---
2151 Op op;
2152 for (int i = 0; i < size; ++i)
2153 vresult = op(vresult, lvec[i]);
2154
2155 return vresult;
2156 }
2157
2158 virtual size_t size() const { return 1; }
2159 /**
2160 * Return true if child of node is binned.
2161 *@return True if child of node is binned.
2162 */
2163 virtual bool binned() const { return l->binned(); }
2164
2165 virtual std::string str() const
2166 {
2167 return csprintf("total(%s)", l->str());
2168 }
2169};
2170
2171
2172//////////////////////////////////////////////////////////////////////
2173//
2174// Visible Statistics Types
2175//
2176//////////////////////////////////////////////////////////////////////
2177/**
2178 * @defgroup VisibleStats "Statistic Types"
2179 * These are the statistics that are used in the simulator. By default these
2180 * store counters and don't use binning, but are templatized to accept any type
2181 * and any Bin class.
2182 * @{
2183 */
2184
2185/**
2186 * This is an easy way to assign all your stats to be binned or not
2187 * binned. If the typedef is NoBin, nothing is binned. If it is
2188 * MainBin, then all stats are binned under that Bin.
2189 */
2190#if STATS_BINNING
2191typedef MainBin DefaultBin;
2192#else
2193typedef NoBin DefaultBin;
2194#endif
2195
2196/**
2197 * This is a simple scalar statistic, like a counter.
2198 * @sa Stat, ScalarBase, StatStor
2199 */
2200template <class Bin = DefaultBin>
2201class Scalar
2202 : public Wrap<Scalar<Bin>,
2203 ScalarBase<StatStor, Bin>,
2204 ScalarStatData>
2205{
2206 public:
2207 /** The base implementation. */
2208 typedef ScalarBase<StatStor, Bin> Base;
2209
2210 Scalar()
2211 {
2212 this->setInit();
2213 }
2214
2215 /**
2216 * Sets the stat equal to the given value. Calls the base implementation
2217 * of operator=
2218 * @param v The new value.
2219 */
2220 template <typename U>
2221 void operator=(const U &v) { Base::operator=(v); }
2222};
2223
2224class Value
2225 : public Wrap<Value,
2226 ValueBase,
2227 ScalarStatData>
2228{
2229 public:
2230 /** The base implementation. */
2231 typedef ValueBase Base;
2232
2233 template <class T>
2234 Value &scalar(T &value)
2235 {
--- 8 unchanged lines hidden (view full) ---
2244 return *this;
2245 }
2246};
2247
2248/**
2249 * A stat that calculates the per cycle average of a value.
2250 * @sa Stat, ScalarBase, AvgStor
2251 */
2252template <class Bin = DefaultBin>
2253class Average
2254 : public Wrap<Average<Bin>,
2255 ScalarBase<AvgStor, Bin>,
2256 ScalarStatData>
2257{
2258 public:
2259 /** The base implementation. */
2260 typedef ScalarBase<AvgStor, Bin> Base;
2261
2262 Average()
2263 {
2264 this->setInit();
2265 }
2266
2267 /**
2268 * Sets the stat equal to the given value. Calls the base implementation
2269 * of operator=
2270 * @param v The new value.
2271 */
2272 template <typename U>
2273 void operator=(const U &v) { Base::operator=(v); }
2274};
2275
2276/**
2277 * A vector of scalar stats.
2278 * @sa Stat, VectorBase, StatStor
2279 */
2280template <class Bin = DefaultBin>
2281class Vector
2282 : public WrapVec<Vector<Bin>,
2283 VectorBase<StatStor, Bin>,
2284 VectorStatData>
2285{
2286 public:
2287 /** The base implementation. */
2288 typedef ScalarBase<StatStor, Bin> Base;
2289
2290 /**
2291 * Set this vector to have the given size.
2292 * @param size The new size.
2293 * @return A reference to this stat.
2294 */
2295 Vector &init(size_t size) {
2296 this->bin.init(size, this->params);
2297 this->setInit();
2298
2299 return *this;
2300 }
2301};
2302
2303/**
2304 * A vector of Average stats.
2305 * @sa Stat, VectorBase, AvgStor
2306 */
2307template <class Bin = DefaultBin>
2308class AverageVector
2309 : public WrapVec<AverageVector<Bin>,
2310 VectorBase<AvgStor, Bin>,
2311 VectorStatData>
2312{
2313 public:
2314 /**
2315 * Set this vector to have the given size.
2316 * @param size The new size.
2317 * @return A reference to this stat.
2318 */
2319 AverageVector &init(size_t size) {
2320 this->bin.init(size, this->params);
2321 this->setInit();
2322
2323 return *this;
2324 }
2325};
2326
2327/**
2328 * A 2-Dimensional vecto of scalar stats.
2329 * @sa Stat, Vector2dBase, StatStor
2330 */
2331template <class Bin = DefaultBin>
2332class Vector2d
2333 : public WrapVec2d<Vector2d<Bin>,
2334 Vector2dBase<StatStor, Bin>,
2335 Vector2dStatData>
2336{
2337 public:
2338 Vector2d &init(size_t _x, size_t _y) {
2339 this->statData()->x = this->x = _x;
2340 this->statData()->y = this->y = _y;
2341 this->bin.init(this->x * this->y, this->params);
2342 this->setInit();
2343
2344 return *this;
2345 }
2346};
2347
2348/**
2349 * A simple distribution stat.
2350 * @sa Stat, DistBase, DistStor
2351 */
2352template <class Bin = DefaultBin>
2353class Distribution
2354 : public Wrap<Distribution<Bin>,
2355 DistBase<DistStor, Bin>,
2356 DistStatData>
2357{
2358 public:
2359 /** Base implementation. */
2360 typedef DistBase<DistStor, Bin> Base;
2361 /** The Parameter type. */
2362 typedef typename DistStor::Params Params;
2363
2364 public:
2365 /**
2366 * Set the parameters of this distribution. @sa DistStor::Params
2367 * @param min The minimum value of the distribution.
2368 * @param max The maximum value of the distribution.
2369 * @param bkt The number of values in each bucket.
2370 * @return A reference to this distribution.
2371 */
2372 Distribution &init(Counter min, Counter max, Counter bkt) {
2373 this->params.min = min;
2374 this->params.max = max;
2375 this->params.bucket_size = bkt;
2376 this->params.size = (int)rint((max - min) / bkt + 1.0);
2377 this->bin.init(this->params);
2378 this->setInit();
2379
2380 return *this;
2381 }
2382};
2383
2384/**
2385 * Calculates the mean and variance of all the samples.
2386 * @sa Stat, DistBase, FancyStor
2387 */
2388template <class Bin = DefaultBin>
2389class StandardDeviation
2390 : public Wrap<StandardDeviation<Bin>,
2391 DistBase<FancyStor, Bin>,
2392 DistStatData>
2393{
2394 public:
2395 /** The base implementation */
2396 typedef DistBase<DistStor, Bin> Base;
2397 /** The parameter type. */
2398 typedef typename DistStor::Params Params;
2399
2400 public:
2401 /**
2402 * Construct and initialize this distribution.
2403 */
2404 StandardDeviation() {
2405 this->bin.init(this->params);
2406 this->setInit();
2407 }
2408};
2409
2410/**
2411 * Calculates the per cycle mean and variance of the samples.
2412 * @sa Stat, DistBase, AvgFancy
2413 */
2414template <class Bin = DefaultBin>
2415class AverageDeviation
2416 : public Wrap<AverageDeviation<Bin>,
2417 DistBase<AvgFancy, Bin>,
2418 DistStatData>
2419{
2420 public:
2421 /** The base implementation */
2422 typedef DistBase<DistStor, Bin> Base;
2423 /** The parameter type. */
2424 typedef typename DistStor::Params Params;
2425
2426 public:
2427 /**
2428 * Construct and initialize this distribution.
2429 */
2430 AverageDeviation()
2431 {
2432 this->bin.init(this->params);
2433 this->setInit();
2434 }
2435};
2436
2437/**
2438 * A vector of distributions.
2439 * @sa Stat, VectorDistBase, DistStor
2440 */
2441template <class Bin = DefaultBin>
2442class VectorDistribution
2443 : public WrapVec<VectorDistribution<Bin>,
2444 VectorDistBase<DistStor, Bin>,
2445 VectorDistStatData>
2446{
2447 public:
2448 /** The base implementation */
2449 typedef VectorDistBase<DistStor, Bin> Base;
2450 /** The parameter type. */
2451 typedef typename DistStor::Params Params;
2452
2453 public:
2454 /**
2455 * Initialize storage and parameters for this distribution.
2456 * @param size The size of the vector (the number of distributions).
2457 * @param min The minimum value of the distribution.
2458 * @param max The maximum value of the distribution.
2459 * @param bkt The number of values in each bucket.
2460 * @return A reference to this distribution.
2461 */
2462 VectorDistribution &init(int size, Counter min, Counter max, Counter bkt) {
2463 this->params.min = min;
2464 this->params.max = max;
2465 this->params.bucket_size = bkt;
2466 this->params.size = (int)rint((max - min) / bkt + 1.0);
2467 this->bin.init(size, this->params);
2468 this->setInit();
2469
2470 return *this;
2471 }
2472};
2473
2474/**
2475 * This is a vector of StandardDeviation stats.
2476 * @sa Stat, VectorDistBase, FancyStor
2477 */
2478template <class Bin = DefaultBin>
2479class VectorStandardDeviation
2480 : public WrapVec<VectorStandardDeviation<Bin>,
2481 VectorDistBase<FancyStor, Bin>,
2482 VectorDistStatData>
2483{
2484 public:
2485 /** The base implementation */
2486 typedef VectorDistBase<FancyStor, Bin> Base;
2487 /** The parameter type. */
2488 typedef typename DistStor::Params Params;
2489
2490 public:
2491 /**
2492 * Initialize storage for this distribution.
2493 * @param size The size of the vector.
2494 * @return A reference to this distribution.
2495 */
2496 VectorStandardDeviation &init(int size) {
2497 this->bin.init(size, this->params);
2498 this->setInit();
2499
2500 return *this;
2501 }
2502};
2503
2504/**
2505 * This is a vector of AverageDeviation stats.
2506 * @sa Stat, VectorDistBase, AvgFancy
2507 */
2508template <class Bin = DefaultBin>
2509class VectorAverageDeviation
2510 : public WrapVec<VectorAverageDeviation<Bin>,
2511 VectorDistBase<AvgFancy, Bin>,
2512 VectorDistStatData>
2513{
2514 public:
2515 /** The base implementation */
2516 typedef VectorDistBase<AvgFancy, Bin> Base;
2517 /** The parameter type. */
2518 typedef typename DistStor::Params Params;
2519
2520 public:
2521 /**
2522 * Initialize storage for this distribution.
2523 * @param size The size of the vector.
2524 * @return A reference to this distribution.
2525 */
2526 VectorAverageDeviation &init(int size) {
2527 this->bin.init(size, this->params);
2528 this->setInit();
2529
2530 return *this;
2531 }
2532};
2533
2534/**
2535 * A formula for statistics that is calculated when printed. A formula is
2536 * stored as a tree of Nodes that represent the equation to calculate.
2537 * @sa Stat, ScalarStat, VectorStat, Node, Temp
--- 27 unchanged lines hidden (view full) ---
2565 */
2566 Result total() const;
2567
2568 /**
2569 * Return the number of elements in the tree.
2570 */
2571 size_t size() const;
2572
2573 /**
2574 * Return true if Formula is binned. i.e. any of its children
2575 * nodes are binned
2576 * @return True if Formula is binned.
2577 */
2578 bool binned() const;
2579
2580 bool check() const { return true; }
2581
2582 /**
2583 * Formulas don't need to be reset
2584 */
2585 void reset();
2586
2587 /**
--- 22 unchanged lines hidden (view full) ---
2610 protected:
2611 Stat &s;
2612 mutable VResult vec;
2613 mutable VCounter cvec;
2614
2615 public:
2616 FormulaStatData(Stat &stat) : s(stat) {}
2617
2618 virtual bool binned() const { return s.binned(); }
2619 virtual bool zero() const { return s.zero(); }
2620 virtual void reset() { s.reset(); }
2621
2622 virtual size_t size() const { return s.size(); }
2623 virtual const VResult &result() const
2624 {
2625 s.result(vec);
2626 return vec;
--- 50 unchanged lines hidden (view full) ---
2677 mutable VResult vec;
2678
2679 public:
2680 FormulaNode(const Formula &f) : formula(f) {}
2681
2682 virtual size_t size() const { return formula.size(); }
2683 virtual const VResult &result() const { formula.result(vec); return vec; }
2684 virtual Result total() const { return formula.total(); }
2685 virtual bool binned() const { return formula.binned(); }
2686
2687 virtual std::string str() const { return formula.str(); }
2688};
2689
2690/**
2691 * Helper class to construct formula node trees.
2692 */
2693class Temp
--- 17 unchanged lines hidden (view full) ---
2711 */
2712 operator NodePtr&() { return node;}
2713
2714 public:
2715 /**
2716 * Create a new ScalarStatNode.
2717 * @param s The ScalarStat to place in a node.
2718 */
2719 template <class Bin>
2720 Temp(const Scalar<Bin> &s)
2721 : node(new ScalarStatNode(s.statData())) { }
2722
2723 /**
2724 * Create a new ScalarStatNode.
2725 * @param s The ScalarStat to place in a node.
2726 */
2727 Temp(const Value &s)
2728 : node(new ScalarStatNode(s.statData())) { }
2729
2730 /**
2731 * Create a new ScalarStatNode.
2732 * @param s The ScalarStat to place in a node.
2733 */
2734 template <class Bin>
2735 Temp(const Average<Bin> &s)
2736 : node(new ScalarStatNode(s.statData())) { }
2737
2738 /**
2739 * Create a new VectorStatNode.
2740 * @param s The VectorStat to place in a node.
2741 */
2742 template <class Bin>
2743 Temp(const Vector<Bin> &s)
2744 : node(new VectorStatNode(s.statData())) { }
2745
2746 /**
2747 *
2748 */
2749 Temp(const Formula &f)
2750 : node(new FormulaNode(f)) { }
2751
2752 /**
2753 * Create a new ScalarProxyNode.
2754 * @param p The ScalarProxy to place in a node.
2755 */
2756 template <class Storage, class Bin>
2757 Temp(const ScalarProxy<Storage, Bin> &p)
2758 : node(new ScalarProxyNode<Storage, Bin>(p)) { }
2759
2760 /**
2761 * Create a ConstNode
2762 * @param value The value of the const node.
2763 */
2764 Temp(signed char value)
2765 : node(new ConstNode<signed char>(value)) {}
2766
--- 133 unchanged lines hidden ---