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/flags.hh"
64#include "base/stats/visit.hh"
65#include "base/stats/types.hh"
66#include "sim/host.hh"
67
68class Callback;
69
70/** The current simulated cycle. */
71extern Tick curTick;
72
73/* A namespace for all of the Statistics */

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

96 * Can be used externally for lookups as well as for debugging.
97 */
98 int id;
99
100 StatData();
101 virtual ~StatData();
102
103 /**
104 * Reset the corresponding stat to the default state.
105 */
106 virtual void reset() = 0;
107
108 /**
109 * @return true if this stat has a value and satisfies its
110 * requirement as a prereq
111 */

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

148class ScalarStatData : public ScalarData
149{
150 protected:
151 Stat &s;
152
153 public:
154 ScalarStatData(Stat &stat) : s(stat) {}
155
156 virtual bool check() const { return s.check(); }
157 virtual Counter value() const { return s.value(); }
158 virtual Result result() const { return s.result(); }
159 virtual Result total() const { return s.total(); }
160 virtual void reset() { s.reset(); }
161 virtual bool zero() const { return s.zero(); }
162};
163

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

190 protected:
191 Stat &s;
192 mutable VCounter cvec;
193 mutable VResult rvec;
194
195 public:
196 VectorStatData(Stat &stat) : s(stat) {}
197
198 virtual bool check() const { return s.check(); }
199 virtual bool zero() const { return s.zero(); }
200 virtual void reset() { s.reset(); }
201
202 virtual size_t size() const { return s.size(); }
203 virtual VCounter &value() const
204 {
205 s.value(cvec);

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

247class DistStatData : public DistData
248{
249 protected:
250 Stat &s;
251
252 public:
253 DistStatData(Stat &stat) : s(stat) {}
254
255 virtual bool check() const { return s.check(); }
256 virtual void reset() { s.reset(); }
257 virtual bool zero() const { return s.zero(); }
258 virtual void visit(Visit &visitor)
259 {
260 s.update(this);
261 visitor.visit(*this);
262 }

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

285 }
286};
287
288template <class Stat>
289class VectorDistStatData : public VectorDistData
290{
291 protected:
292 Stat &s;
293
294 public:
295 VectorDistStatData(Stat &stat) : s(stat) {}
296
297 virtual bool check() const { return s.check(); }
298 virtual void reset() { s.reset(); }
299 virtual size_t size() const { return s.size(); }
300 virtual bool zero() const { return s.zero(); }
301 virtual void visit(Visit &visitor)
302 {
303 update();
304 s.update(this);

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

325 }
326};
327
328template <class Stat>
329class Vector2dStatData : public Vector2dData
330{
331 protected:
332 Stat &s;
333
334 public:
335 Vector2dStatData(Stat &stat) : s(stat) {}
336
337 virtual bool check() const { return s.check(); }
338 virtual void reset() { s.reset(); }
339 virtual bool zero() const { return s.zero(); }
340 virtual void visit(Visit &visitor)
341 {
342 update();
343 s.update(this);
344 visitor.visit(*this);
345 }
346};
347
348class DataAccess
349{
350 protected:
351 StatData *find() const;
352 void map(StatData *data);
353
354 StatData *statData();
355 const StatData *statData() const;

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

595};
596
597/**
598 * Templatized storage and interface to a per-cycle average stat. This keeps
599 * a current count and updates a total (count * cycles) when this count
600 * changes. This allows the quick calculation of a per cycle count of the item
601 * being watched. This is good for keeping track of residencies in structures
602 * among other things.
603 */
604struct AvgStor
605{
606 public:
607 /** The paramaters for this storage type */
608 struct Params { };
609
610 private:
611 /** The current count. */
612 Counter current;
613 /** The total count for all cycles. */
614 mutable Result total;
615 /** The cycle that current last changed. */
616 mutable Tick last;
617
618 public:
619 /**
620 * Build and initializes this stat storage.
621 */
622 AvgStor(Params &p) : current(0), total(0), last(0) { }
623
624 /**
625 * Set the current count to the one provided, update the total and last
626 * set values.
627 * @param val The new count.
628 * @param p The parameters for this storage.
629 */
630 void set(Counter val, Params &p) {
631 total += current * (curTick - last);
632 last = curTick;
633 current = val;
634 }
635
636 /**
637 * Increment the current count by the provided value, calls set.
638 * @param val The amount to increment.
639 * @param p The parameters for this storage.
640 */
641 void inc(Counter val, Params &p) { set(current + val, p); }
642
643 /**
644 * Deccrement the current count by the provided value, calls set.
645 * @param val The amount to decrement.
646 * @param p The parameters for this storage.
647 */
648 void dec(Counter val, Params &p) { set(current - val, p); }
649
650 /**
651 * Return the current count.
652 * @param p The parameters for this storage.
653 * @return The current count.
654 */
655 Counter value(const Params &p) const { return current; }
656
657 /**
658 * Return the current average.
659 * @param p The parameters for this storage.
660 * @return The current average.
661 */
662 Result result(const Params &p) const
663 {
664 total += current * (curTick - last);
665 last = curTick;
666 return (Result)(total + current) / (Result)(curTick + 1);
667 }
668
669 /**
670 * Reset stat value to default
671 */
672 void reset()
673 {
674 total = 0;
675 last = curTick;
676 }
677
678 /**
679 * @return true if zero value
680 */
681 bool zero() const { return total == 0.0; }
682};
683
684/**
685 * Implementation of a scalar stat. The type of stat is determined by the
686 * Storage template.
687 */
688template
689class ScalarBase : public DataAccess
690{
691 public:
692 typedef Stor Storage;
693
694 /** Define the params of the storage class. */
695 typedef typename Storage::Params Params;
696
697 protected:
698 /** The storage of this stat. */
699 char storage[sizeof(Storage)];
700
701 /** The parameters for this stat. */
702 Params params;
703
704 protected:
705 /**
706 * Retrieve the storage.
707 * @param index The vector index to access.
708 * @return The storage object at the given index.
709 */
710 Storage *
711 data()
712 {
713 return reinterpret_cast<Storage *>(storage);
714 }
715
716 /**
717 * Retrieve a const pointer to the storage.
718 * for the given index.
719 * @param index The vector index to access.
720 * @return A const pointer to the storage object at the given index.
721 */
722 const Storage *
723 data() const
724 {
725 return reinterpret_cast<const Storage *>(storage);
726 }
727
728 void
729 doInit()
730 {
731 new (storage) Storage(params);
732 setInit();
733 }
734
735 public:
736 /**
737 * Return the current value of this stat as its base type.
738 * @return The current value.
739 */
740 Counter value() const { return data()->value(params); }
741
742 public:
743 /**
744 * Create and initialize this stat, register it with the database.
745 */
746 ScalarBase()
747 { }
748
749 public:
750 // Common operators for stats
751 /**
752 * Increment the stat by 1. This calls the associated storage object inc
753 * function.
754 */
755 void operator++() { data()->inc(1, params); }

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

788 template <typename U>
789 void operator-=(const U &v) { data()->dec(v, params); }
790
791 /**
792 * Return the number of elements, always 1 for a scalar.
793 * @return 1.
794 */
795 size_t size() const { return 1; }
796
797 bool check() const { return true; }
798
799 /**
800 * Reset stat value to default
801 */
802 void reset() { data()->reset(); }
803
804 Counter value() { return data()->value(params); }
805
806 Result result() { return data()->result(params); }
807
808 Result total() { return result(); }
809
810 bool zero() { return result() == 0.0; }
811
812};
813
814class ProxyData : public ScalarData
815{
816 public:
817 virtual void visit(Visit &visitor) { visitor.visit(*this); }
818 virtual std::string str() const { return to_string(value()); }
819 virtual size_t size() const { return 1; }
820 virtual bool zero() const { return value() == 0; }
821 virtual bool check() const { return true; }
822 virtual void reset() { }
823};
824
825template <class T>

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

871 setInit();
872 }
873
874 Counter value() { return proxy->value(); }
875 Result result() const { return proxy->result(); }
876 Result total() const { return proxy->total(); };
877 size_t size() const { return proxy->size(); }
878
879 std::string str() const { return proxy->str(); }
880 bool zero() const { return proxy->zero(); }
881 bool check() const { return proxy != NULL; }
882 void reset() { }
883};
884
885//////////////////////////////////////////////////////////////////////
886//
887// Vector Statistics
888//
889//////////////////////////////////////////////////////////////////////
890
891/**
892 * A proxy class to access the stat at a given index in a VectorBase stat.
893 * Behaves like a ScalarBase.
894 */
895template <class Stat>
896class ScalarProxy
897{
898 private:
899 /** Pointer to the parent Vector. */
900 Stat *stat;
901
902 /** The index to access in the parent VectorBase. */
903 int index;
904
905 public:
906 /**
907 * Return the current value of this stat as its base type.
908 * @return The current value.
909 */
910 Counter value() const { return stat->data(index)->value(stat->params); }
911
912 /**
913 * Return the current value of this statas a result type.
914 * @return The current value.
915 */
916 Result result() const { return stat->data(index)->result(stat->params); }
917
918 public:
919 /**
920 * Create and initialize this proxy, do not register it with the database.
921 * @param p The params to use.
922 * @param i The index to access.
923 */
924 ScalarProxy(Stat *s, int i)
925 : stat(s), index(i)
926 {
927 assert(stat);
928 }
929
930 /**
931 * Create a copy of the provided ScalarProxy.
932 * @param sp The proxy to copy.
933 */
934 ScalarProxy(const ScalarProxy &sp)
935 : stat(sp.stat), index(sp.index)
936 {}
937
938 /**
939 * Set this proxy equal to the provided one.
940 * @param sp The proxy to copy.
941 * @return A reference to this proxy.
942 */
943 const ScalarProxy &operator=(const ScalarProxy &sp) {
944 stat = sp.stat;
945 index = sp.index;
946 return *this;
947 }
948
949 public:
950 // Common operators for stats
951 /**
952 * Increment the stat by 1. This calls the associated storage object inc
953 * function.
954 */
955 void operator++() { stat->data(index)->inc(1, stat->params); }
956 /**
957 * Decrement the stat by 1. This calls the associated storage object dec
958 * function.
959 */
960 void operator--() { stat->data(index)->dec(1, stat->params); }
961
962 /** Increment the stat by 1. */
963 void operator++(int) { ++*this; }
964 /** Decrement the stat by 1. */
965 void operator--(int) { --*this; }
966
967 /**
968 * Set the data value to the given value. This calls the associated storage
969 * object set function.
970 * @param v The new value.
971 */
972 template <typename U>
973 void operator=(const U &v) { stat->data(index)->set(v, stat->params); }
974
975 /**
976 * Increment the stat by the given value. This calls the associated
977 * storage object inc function.
978 * @param v The value to add.
979 */
980 template <typename U>
981 void operator+=(const U &v) { stat->data(index)->inc(v, stat->params); }
982
983 /**
984 * Decrement the stat by the given value. This calls the associated
985 * storage object dec function.
986 * @param v The value to substract.
987 */
988 template <typename U>
989 void operator-=(const U &v) { stat->data(index)->dec(v, stat->params); }
990
991 /**
992 * Return the number of elements, always 1 for a scalar.
993 * @return 1.
994 */
995 size_t size() const { return 1; }
996
997 /**
998 * This stat has no state. Nothing to reset
999 */
1000 void reset() { }
1001
1002 public:
1003 std::string
1004 str() const
1005 {
1006 return csprintf("%s[%d]", stat->str(), index);
1007
1008 }
1009};
1010
1011/**
1012 * Implementation of a vector of stats. The type of stat is determined by the
1013 * Storage class. @sa ScalarBase
1014 */
1015template <class Stor>
1016class VectorBase : public DataAccess
1017{
1018 public:
1019 typedef Stor Storage;
1020
1021 /** Define the params of the storage class. */
1022 typedef typename Storage::Params Params;
1023
1024 /** Proxy type */
1025 typedef ScalarProxy<VectorBase<Storage> > Proxy;
1026
1027 friend class ScalarProxy<VectorBase<Storage> >;
1028
1029 protected:
1030 /** The storage of this stat. */
1031 Storage *storage;
1032 size_t _size;
1033
1034 /** The parameters for this stat. */
1035 Params params;
1036
1037 protected:
1038 /**
1039 * Retrieve the storage.
1040 * @param index The vector index to access.
1041 * @return The storage object at the given index.
1042 */
1043 Storage *data(int index) { return &storage[index]; }
1044
1045 /**
1046 * Retrieve a const pointer to the storage.
1047 * @param index The vector index to access.
1048 * @return A const pointer to the storage object at the given index.
1049 */
1050 const Storage *data(int index) const { return &storage[index]; }
1051
1052 void
1053 doInit(int s)
1054 {
1055 assert(s > 0 && "size must be positive!");
1056 assert(!storage && "already initialized");
1057 _size = s;
1058
1059 char *ptr = new char[_size * sizeof(Storage)];
1060 storage = reinterpret_cast<Storage *>(ptr);
1061
1062 for (int i = 0; i < _size; ++i)
1063 new (&storage[i]) Storage(params);
1064
1065 setInit();
1066 }
1067
1068 public:
1069 void value(VCounter &vec) const
1070 {
1071 vec.resize(size());
1072 for (int i = 0; i < size(); ++i)
1073 vec[i] = data(i)->value(params);
1074 }
1075
1076 /**
1077 * Copy the values to a local vector and return a reference to it.
1078 * @return A reference to a vector of the stat values.
1079 */
1080 void result(VResult &vec) const
1081 {
1082 vec.resize(size());
1083 for (int i = 0; i < size(); ++i)
1084 vec[i] = data(i)->result(params);
1085 }
1086
1087 /**
1088 * Return a total of all entries in this vector.
1089 * @return The total of all vector entries.
1090 */
1091 Result total() const {
1092 Result total = 0.0;
1093 for (int i = 0; i < size(); ++i)
1094 total += data(i)->result(params);
1095 return total;
1096 }
1097
1098 /**
1099 * @return the number of elements in this vector.
1100 */
1101 size_t size() const { return _size; }
1102
1103 bool
1104 zero() const
1105 {
1106 for (int i = 0; i < size(); ++i)
1107 if (data(i)->zero())
1108 return false;
1109 return true;
1110 }
1111
1112 bool
1113 check() const
1114 {
1115 return storage != NULL;
1116 }
1117
1118 void
1119 reset()
1120 {
1121 for (int i = 0; i < size(); ++i)
1122 data(i)->reset();
1123 }
1124
1125 public:
1126 VectorBase()
1127 : storage(NULL)
1128 {}
1129
1130 ~VectorBase()
1131 {
1132 if (!storage)
1133 return;
1134
1135 for (int i = 0; i < _size; ++i)
1136 data(i)->~Storage();
1137 delete [] reinterpret_cast<char *>(storage);
1138 }
1139
1140 /**
1141 * Return a reference (ScalarProxy) to the stat at the given index.
1142 * @param index The vector index to access.
1143 * @return A reference of the stat.
1144 */
1145 Proxy
1146 operator[](int index)
1147 {
1148 assert (index >= 0 && index < size());
1149 return Proxy(this, index);
1150 }
1151
1152 void update(StatData *data) {}
1153};
1154
1155template <class Stat>
1156class VectorProxy
1157{
1158 private:
1159 Stat *stat;
1160 int offset;
1161 int len;
1162
1163 private:
1164 mutable VResult vec;
1165
1166 typename Stat::Storage *
1167 data(int index)
1168 {
1169 assert(index < len);
1170 return stat->data(offset + index);
1171 }
1172
1173 const typename Stat::Storage *
1174 data(int index) const
1175 {
1176 assert(index < len);
1177 return const_cast<Stat *>(stat)->data(offset + index);
1178 }
1179
1180 public:
1181 const VResult &
1182 result() const
1183 {
1184 vec.resize(size());
1185
1186 for (int i = 0; i < size(); ++i)
1187 vec[i] = data(i)->result(stat->params);
1188
1189 return vec;
1190 }
1191
1192 Result
1193 total() const
1194 {
1195 Result total = 0;
1196 for (int i = 0; i < size(); ++i)
1197 total += data(i)->result(stat->params);
1198 return total;
1199 }
1200
1201 public:
1202 VectorProxy(Stat *s, int o, int l)
1203 : stat(s), offset(o), len(l)
1204 {
1205 }
1206
1207 VectorProxy(const VectorProxy &sp)
1208 : stat(sp.stat), offset(sp.offset), len(sp.len)
1209 {
1210 }
1211
1212 const VectorProxy &
1213 operator=(const VectorProxy &sp)
1214 {
1215 stat = sp.stat;
1216 offset = sp.offset;
1217 len = sp.len;
1218 return *this;
1219 }
1220
1221 ScalarProxy<Stat> operator[](int index)
1222 {
1223 assert (index >= 0 && index < size());
1224 return ScalarProxy<Stat>(stat, offset + index);
1225 }
1226
1227 size_t size() const { return len; }
1228
1229 /**
1230 * This stat has no state. Nothing to reset.
1231 */
1232 void reset() { }
1233};
1234
1235template
1236class Vector2dBase : public DataAccess
1237{
1238 public:
1239 typedef Stor Storage;
1240 typedef typename Storage::Params Params;
1241 typedef VectorProxy<Vector2dBase<Storage> > Proxy;
1242 friend class ScalarProxy<Vector2dBase<Storage> >;
1243 friend class VectorProxy<Vector2dBase<Storage> >;
1244
1245 protected:
1246 size_t x;
1247 size_t y;
1248 size_t _size;
1249 Storage *storage;
1250 Params params;
1251
1252 protected:
1253 Storage *data(int index) { return &storage[index]; }
1254 const Storage *data(int index) const { return &storage[index]; }
1255
1256 void
1257 doInit(int _x, int _y)
1258 {
1259 assert(_x > 0 && _y > 0 && "sizes must be positive!");
1260 assert(!storage && "already initialized");
1261
1262 Vector2dData *statdata = dynamic_cast<Vector2dData *>(find());
1263
1264 x = _x;
1265 y = _y;
1266 statdata->x = _x;
1267 statdata->y = _y;
1268 _size = x * y;
1269
1270 char *ptr = new char[_size * sizeof(Storage)];
1271 storage = reinterpret_cast<Storage *>(ptr);
1272
1273 for (int i = 0; i < _size; ++i)
1274 new (&storage[i]) Storage(params);
1275
1276 setInit();
1277 }
1278
1279 public:
1280 Vector2dBase()
1281 : storage(NULL)
1282 {}
1283
1284 ~Vector2dBase()
1285 {
1286 if (!storage)
1287 return;
1288
1289 for (int i = 0; i < _size; ++i)
1290 data(i)->~Storage();
1291 delete [] reinterpret_cast<char *>(storage);
1292 }
1293
1294 void
1295 update(Vector2dData *newdata)
1296 {
1297 int size = this->size();
1298 newdata->cvec.resize(size);
1299 for (int i = 0; i < size; ++i)
1300 newdata->cvec[i] = data(i)->value(params);
1301 }
1302
1303 std::string ysubname(int i) const { return (*this->y_subnames)[i]; }
1304
1305 Proxy
1306 operator[](int index)
1307 {
1308 int offset = index * y;
1309 assert (index >= 0 && offset + index < size());
1310 return Proxy(this, offset, y);
1311 }
1312
1313
1314 size_t
1315 size() const
1316 {
1317 return _size;
1318 }
1319
1320 bool
1321 zero() const
1322 {
1323 return data(0)->zero();
1324#if 0
1325 for (int i = 0; i < size(); ++i)
1326 if (!data(i)->zero())
1327 return false;
1328 return true;
1329#endif
1330 }
1331
1332 /**
1333 * Reset stat value to default
1334 */
1335 void
1336 reset()
1337 {
1338 for (int i = 0; i < size(); ++i)
1339 data(i)->reset();
1340 }
1341
1342 bool
1343 check()
1344 {
1345 return storage != NULL;
1346 }
1347};
1348
1349//////////////////////////////////////////////////////////////////////
1350//
1351// Non formula statistics
1352//
1353//////////////////////////////////////////////////////////////////////
1354
1355/**
1356 * Templatized storage and interface for a distrbution stat.

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

1386 /** The sum of squares. */
1387 Counter squares;
1388 /** The number of samples. */
1389 Counter samples;
1390 /** Counter for each bucket. */
1391 VCounter cvec;
1392
1393 public:
1394 DistStor(const Params &params)
1395 : cvec(params.size)
1396 {
1397 reset();
1398 }
1399
1400 /**
1401 * Add a value to the distribution for the given number of times.
1402 * @param val The value to add.
1403 * @param number The number of times to add the value.

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

1622 squares = Counter();
1623 }
1624};
1625
1626/**
1627 * Implementation of a distribution stat. The type of distribution is
1628 * determined by the Storage template. @sa ScalarBase
1629 */
1630template
1631class DistBase : public DataAccess
1632{
1633 public:
1634 typedef Stor Storage;
1635 /** Define the params of the storage class. */
1636 typedef typename Storage::Params Params;
1637
1638 protected:
1639 /** The storage for this stat. */
1640 char storage[sizeof(Storage)];
1641
1642 /** The parameters for this stat. */
1643 Params params;
1644
1645 protected:
1646 /**
1647 * Retrieve the storage.
1648 * @return The storage object for this stat.
1649 */
1650 Storage *data()
1651 {
1652 return reinterpret_cast<Storage *>(storage);
1653 }
1654
1655 /**
1656 * Retrieve a const pointer to the storage.
1657 * @return A const pointer to the storage object for this stat.
1658 */
1659 const Storage *
1660 data() const
1661 {
1662 return reinterpret_cast<const Storage *>(storage);
1663 }
1664
1665 void
1666 doInit()
1667 {
1668 new (storage) Storage(params);
1669 setInit();
1670 }
1671
1672 public:
1673 DistBase() { }
1674
1675 /**
1676 * Add a value to the distribtion n times. Calls sample on the storage
1677 * class.
1678 * @param v The value to add.
1679 * @param n The number of times to add it, defaults to 1.

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

1692 */
1693 bool zero() const { return data()->zero(params); }
1694
1695 void update(DistData *base)
1696 {
1697 base->data.fancy = Storage::fancy;
1698 data()->update(&(base->data), params);
1699 }
1700
1701 /**
1702 * Reset stat value to default
1703 */
1704 void
1705 reset()
1706 {
1707 data()->reset();
1708 }
1709
1710 bool
1711 check()
1712 {
1713 return true;
1714 }
1715};
1716
1717template <class Stat>
1718class DistProxy;
1719
1720template
1721class VectorDistBase : public DataAccess
1722{
1723 public:
1724 typedef Stor Storage;
1725 typedef typename Storage::Params Params;
1726 typedef DistProxy<VectorDistBase<Storage> > Proxy;
1727 friend class DistProxy<VectorDistBase<Storage> >;
1728
1729 protected:
1730 Storage *storage;
1731 size_t _size;
1732 Params params;
1733
1734 protected:
1735 Storage *
1736 data(int index)
1737 {
1738 return &storage[index];
1739 }
1740
1741 const Storage *
1742 data(int index) const
1743 {
1744 return &storage[index];
1745 }
1746
1747 void
1748 doInit(int s)
1749 {
1750 assert(s > 0 && "size must be positive!");
1751 assert(!storage && "already initialized");
1752 _size = s;
1753
1754 char *ptr = new char[_size * sizeof(Storage)];
1755 storage = reinterpret_cast<Storage *>(ptr);
1756
1757 for (int i = 0; i < _size; ++i)
1758 new (&storage[i]) Storage(params);
1759
1760 setInit();
1761 }
1762
1763 public:
1764 VectorDistBase()
1765 : storage(NULL)
1766 {}
1767
1768 ~VectorDistBase()
1769 {
1770 if (!storage)
1771 return ;
1772
1773 for (int i = 0; i < _size; ++i)
1774 data(i)->~Storage();
1775 delete [] reinterpret_cast<char *>(storage);
1776 }
1777
1778 Proxy operator[](int index);
1779
1780 size_t
1781 size() const
1782 {
1783 return _size;
1784 }
1785
1786 bool
1787 zero() const
1788 {
1789 return false;
1790#if 0
1791 for (int i = 0; i < size(); ++i)
1792 if (!data(i)->zero(params))
1793 return false;
1794 return true;
1795#endif
1796 }
1797
1798 /**
1799 * Reset stat value to default
1800 */
1801 void
1802 reset()
1803 {
1804 for (int i = 0; i < size(); ++i)
1805 data(i)->reset();
1806 }
1807
1808 bool
1809 check()
1810 {
1811 return storage != NULL;
1812 }
1813
1814 void
1815 update(VectorDistData *base)
1816 {
1817 int size = this->size();
1818 base->data.resize(size);
1819 for (int i = 0; i < size; ++i) {
1820 base->data[i].fancy = Storage::fancy;
1821 data(i)->update(&(base->data[i]), params);
1822 }
1823 }
1824};
1825
1826template <class Stat>
1827class DistProxy
1828{
1829 private:
1830 Stat *stat;
1831 int index;
1832
1833 protected:
1834 typename Stat::Storage *data() { return stat->data(index); }
1835 const typename Stat::Storage *data() const { return stat->data(index); }
1836
1837 public:
1838 DistProxy(Stat *s, int i)
1839 : stat(s), index(i)
1840 {}
1841
1842 DistProxy(const DistProxy &sp)
1843 : stat(sp.stat), index(sp.index)
1844 {}
1845
1846 const DistProxy &operator=(const DistProxy &sp)
1847 {
1848 stat = sp.stat;
1849 index = sp.index;
1850 return *this;
1851 }
1852
1853 public:
1854 template <typename U>
1855 void
1856 sample(const U &v, int n = 1)
1857 {
1858 data()->sample(v, n, stat->params);
1859 }
1860
1861 size_t
1862 size() const
1863 {
1864 return 1;
1865 }
1866
1867 bool
1868 zero() const
1869 {
1870 return data()->zero(stat->params);
1871 }
1872
1873 /**
1874 * Proxy has no state. Nothing to reset.
1875 */
1876 void reset() { }
1877};
1878
1879template
1880inline typename VectorDistBase<Storage>::Proxy
1881VectorDistBase::operator[](int index)
1882{
1883 assert (index >= 0 && index < size());
1884 return typename VectorDistBase<Storage>::Proxy(this, index);
1885}
1886
1887#if 0
1888template
1889Result
1890VectorDistBase::total(int index) const
1891{
1892 int total = 0;
1893 for (int i = 0; i < x_size(); ++i) {
1894 total += data(i)->result(stat->params);
1895 }
1896}
1897#endif
1898
1899//////////////////////////////////////////////////////////////////////
1900//
1901// Formula Details
1902//

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

1919 * @return The result vector of this subtree.
1920 */
1921 virtual const VResult &result() const = 0;
1922 /**
1923 * Return the total of the result vector.
1924 * @return The total of the result vector.
1925 */
1926 virtual Result total() const = 0;
1927
1928 /**
1929 *
1930 */
1931 virtual std::string str() const = 0;
1932};
1933
1934/** Reference counting pointer to a function Node. */

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

1945 virtual const VResult &result() const
1946 {
1947 vresult[0] = data->result();
1948 return vresult;
1949 }
1950 virtual Result total() const { return data->result(); };
1951
1952 virtual size_t size() const { return 1; }
1953
1954 /**
1955 *
1956 */
1957 virtual std::string str() const { return data->name; }
1958};
1959
1960template <class Stat>
1961class ScalarProxyNode : public Node
1962{
1963 private:
1964 const ScalarProxy<Stat> proxy;
1965 mutable VResult vresult;
1966
1967 public:
1968 ScalarProxyNode(const ScalarProxy<Stat> &p)
1969 : proxy(p), vresult(1)
1970 { }
1971
1972 virtual const VResult &
1973 result() const
1974 {
1975 vresult[0] = proxy.result();
1976 return vresult;
1977 }
1978
1979 virtual Result
1980 total() const
1981 {
1982 return proxy.result();
1983 }
1984
1985 virtual size_t
1986 size() const
1987 {
1988 return 1;
1989 }
1990
1991 /**
1992 *
1993 */
1994 virtual std::string
1995 str() const
1996 {
1997 return proxy.str();
1998 }
1999};
2000
2001class VectorStatNode : public Node
2002{
2003 private:
2004 const VectorData *data;
2005
2006 public:
2007 VectorStatNode(const VectorData *d) : data(d) { }
2008 virtual const VResult &result() const { return data->result(); }
2009 virtual Result total() const { return data->total(); };
2010
2011 virtual size_t size() const { return data->size(); }
2012
2013 virtual std::string str() const { return data->name; }
2014};
2015
2016template <class T>
2017class ConstNode : public Node
2018{
2019 private:
2020 VResult vresult;
2021
2022 public:
2023 ConstNode(T s) : vresult(1, (Result)s) {}
2024 const VResult &result() const { return vresult; }
2025 virtual Result total() const { return vresult[0]; };
2026 virtual size_t size() const { return 1; }
2027 virtual std::string str() const { return to_string(vresult[0]); }
2028};
2029
2030template <class Op>
2031struct OpString;
2032
2033template<>
2034struct OpString<std::plus<Result> >

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

2092 }
2093
2094 Result total() const {
2095 Op op;
2096 return op(l->total());
2097 }
2098
2099 virtual size_t size() const { return l->size(); }
2100
2101 virtual std::string str() const
2102 {
2103 return OpString<Op>::str() + l->str();
2104 }
2105};
2106
2107template <class Op>

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

2158 return rs;
2159 else if (rs == 1)
2160 return ls;
2161 else {
2162 assert(ls == rs && "Node vector sizes are not equal");
2163 return ls;
2164 }
2165 }
2166
2167 virtual std::string str() const
2168 {
2169 return csprintf("(%s %s %s)", l->str(), OpString<Op>::str(), r->str());
2170 }
2171};
2172
2173template <class Op>

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

2206 Op op;
2207 for (int i = 0; i < size; ++i)
2208 vresult = op(vresult, lvec[i]);
2209
2210 return vresult;
2211 }
2212
2213 virtual size_t size() const { return 1; }
2214
2215 virtual std::string str() const
2216 {
2217 return csprintf("total(%s)", l->str());
2218 }
2219};
2220
2221
2222//////////////////////////////////////////////////////////////////////
2223//
2224// Visible Statistics Types
2225//
2226//////////////////////////////////////////////////////////////////////
2227/**
2228 * @defgroup VisibleStats "Statistic Types"
2229 * These are the statistics that are used in the simulator.
2230 * @{
2231 */
2232
2233/**
2234 * This is a simple scalar statistic, like a counter.
2235 * @sa Stat, ScalarBase, StatStor
2236 */
2237template<int N = 0>
2238class Scalar : public Wrap<Scalar<N>, ScalarBase<StatStor>, ScalarStatData>
2239{
2240 public:
2241 /** The base implementation. */
2242 typedef ScalarBase Base;
2243
2244 Scalar()
2245 {
2246 this->doInit();
2247 }
2248
2249 /**
2250 * Sets the stat equal to the given value. Calls the base implementation
2251 * of operator=
2252 * @param v The new value.
2253 */
2254 template <typename U>
2255 void operator=(const U &v) { Base::operator=(v); }
2256};
2257
2258class Value : public Wrap<Value, ValueBase, ScalarStatData>
2259{
2260 public:
2261 /** The base implementation. */
2262 typedef ValueBase Base;
2263
2264 template <class T>
2265 Value &scalar(T &value)
2266 {

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

2275 return *this;
2276 }
2277};
2278
2279/**
2280 * A stat that calculates the per cycle average of a value.
2281 * @sa Stat, ScalarBase, AvgStor
2282 */
2283template<int N = 0>
2284class Average : public Wrap<Average<N>, ScalarBase<AvgStor>, ScalarStatData>
2285{
2286 public:
2287 /** The base implementation. */
2288 typedef ScalarBase Base;
2289
2290 Average()
2291 {
2292 this->doInit();
2293 }
2294
2295 /**
2296 * Sets the stat equal to the given value. Calls the base implementation
2297 * of operator=
2298 * @param v The new value.
2299 */
2300 template <typename U>
2301 void operator=(const U &v) { Base::operator=(v); }
2302};
2303
2304/**
2305 * A vector of scalar stats.
2306 * @sa Stat, VectorBase, StatStor
2307 */
2308template<int N = 0>
2309class Vector : public WrapVec<Vector<N>, VectorBase<StatStor>, VectorStatData>
2310{
2311 public:
2312 /** The base implementation. */
2313 typedef ScalarBase Base;
2314
2315 /**
2316 * Set this vector to have the given size.
2317 * @param size The new size.
2318 * @return A reference to this stat.
2319 */
2320 Vector &init(size_t size) {
2321 this->doInit(size);
2322 return *this;
2323 }
2324};
2325
2326/**
2327 * A vector of Average stats.
2328 * @sa Stat, VectorBase, AvgStor
2329 */
2330template<int N = 0>
2331class AverageVector
2332 : public WrapVec<AverageVector<N>, VectorBase<AvgStor>, VectorStatData>
2333{
2334 public:
2335 /**
2336 * Set this vector to have the given size.
2337 * @param size The new size.
2338 * @return A reference to this stat.
2339 */
2340 AverageVector &init(size_t size) {
2341 this->doInit(size);
2342 return *this;
2343 }
2344};
2345
2346/**
2347 * A 2-Dimensional vecto of scalar stats.
2348 * @sa Stat, Vector2dBase, StatStor
2349 */
2350template<int N = 0>
2351class Vector2d
2352 : public WrapVec2d<Vector2d<N>, Vector2dBase<StatStor>, Vector2dStatData>
2353{
2354 public:
2355 Vector2d &init(size_t x, size_t y) {
2356 this->doInit(x, y);
2357 return *this;
2358 }
2359};
2360
2361/**
2362 * A simple distribution stat.
2363 * @sa Stat, DistBase, DistStor
2364 */
2365template<int N = 0>
2366class Distribution
2367 : public Wrap<Distribution<N>, DistBase<DistStor>, DistStatData>
2368{
2369 public:
2370 /** Base implementation. */
2371 typedef DistBase Base;
2372 /** The Parameter type. */
2373 typedef DistStor::Params Params;
2374
2375 public:
2376 /**
2377 * Set the parameters of this distribution. @sa DistStor::Params
2378 * @param min The minimum value of the distribution.
2379 * @param max The maximum value of the distribution.
2380 * @param bkt The number of values in each bucket.
2381 * @return A reference to this distribution.
2382 */
2383 Distribution &init(Counter min, Counter max, Counter bkt) {
2384 this->params.min = min;
2385 this->params.max = max;
2386 this->params.bucket_size = bkt;
2387 this->params.size = (int)rint((max - min) / bkt + 1.0);
2388 this->doInit();
2389 return *this;
2390 }
2391};
2392
2393/**
2394 * Calculates the mean and variance of all the samples.
2395 * @sa Stat, DistBase, FancyStor
2396 */
2397template<int N = 0>
2398class StandardDeviation
2399 : public Wrap<StandardDeviation<N>, DistBase<FancyStor>, DistStatData>
2400{
2401 public:
2402 /** The base implementation */
2403 typedef DistBase Base;
2404 /** The parameter type. */
2405 typedef DistStor::Params Params;
2406
2407 public:
2408 /**
2409 * Construct and initialize this distribution.
2410 */
2411 StandardDeviation() {
2412 this->doInit();
2413 }
2414};
2415
2416/**
2417 * Calculates the per cycle mean and variance of the samples.
2418 * @sa Stat, DistBase, AvgFancy
2419 */
2420template<int N = 0>
2421class AverageDeviation
2422 : public Wrap<AverageDeviation<N>, DistBase<AvgFancy>, DistStatData>
2423{
2424 public:
2425 /** The base implementation */
2426 typedef DistBase Base;
2427 /** The parameter type. */
2428 typedef DistStor::Params Params;
2429
2430 public:
2431 /**
2432 * Construct and initialize this distribution.
2433 */
2434 AverageDeviation()
2435 {
2436 this->doInit();
2437 }
2438};
2439
2440/**
2441 * A vector of distributions.
2442 * @sa Stat, VectorDistBase, DistStor
2443 */
2444template<int N = 0>
2445class VectorDistribution
2446 : public WrapVec<VectorDistribution<N>,
2447 VectorDistBase,
2448 VectorDistStatData>
2449{
2450 public:
2451 /** The base implementation */
2452 typedef VectorDistBase Base;
2453 /** The parameter type. */
2454 typedef DistStor::Params Params;
2455
2456 public:
2457 /**
2458 * Initialize storage and parameters for this distribution.
2459 * @param size The size of the vector (the number of distributions).
2460 * @param min The minimum value of the distribution.
2461 * @param max The maximum value of the distribution.
2462 * @param bkt The number of values in each bucket.
2463 * @return A reference to this distribution.
2464 */
2465 VectorDistribution &init(int size, Counter min, Counter max, Counter bkt) {
2466 this->params.min = min;
2467 this->params.max = max;
2468 this->params.bucket_size = bkt;
2469 this->params.size = (int)rint((max - min) / bkt + 1.0);
2470 this->doInit(size);
2471 return *this;
2472 }
2473};
2474
2475/**
2476 * This is a vector of StandardDeviation stats.
2477 * @sa Stat, VectorDistBase, FancyStor
2478 */
2479template<int N = 0>
2480class VectorStandardDeviation
2481 : public WrapVec<VectorStandardDeviation<N>,
2482 VectorDistBase,
2483 VectorDistStatData>
2484{
2485 public:
2486 /** The base implementation */
2487 typedef VectorDistBase Base;
2488 /** The parameter type. */
2489 typedef DistStor::Params Params;
2490
2491 public:
2492 /**
2493 * Initialize storage for this distribution.
2494 * @param size The size of the vector.
2495 * @return A reference to this distribution.
2496 */
2497 VectorStandardDeviation &init(int size) {
2498 this->doInit(size);
2499 return *this;
2500 }
2501};
2502
2503/**
2504 * This is a vector of AverageDeviation stats.
2505 * @sa Stat, VectorDistBase, AvgFancy
2506 */
2507template<int N = 0>
2508class VectorAverageDeviation
2509 : public WrapVec<VectorAverageDeviation<N>,
2510 VectorDistBase,
2511 VectorDistStatData>
2512{
2513 public:
2514 /** The base implementation */
2515 typedef VectorDistBase Base;
2516 /** The parameter type. */
2517 typedef DistStor::Params Params;
2518
2519 public:
2520 /**
2521 * Initialize storage for this distribution.
2522 * @param size The size of the vector.
2523 * @return A reference to this distribution.
2524 */
2525 VectorAverageDeviation &init(int size) {
2526 this->doInit(size);
2527 return *this;
2528 }
2529};
2530
2531/**
2532 * A formula for statistics that is calculated when printed. A formula is
2533 * stored as a tree of Nodes that represent the equation to calculate.
2534 * @sa Stat, ScalarStat, VectorStat, Node, Temp

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

2562 */
2563 Result total() const;
2564
2565 /**
2566 * Return the number of elements in the tree.
2567 */
2568 size_t size() const;
2569
2570 bool check() const { return true; }
2571
2572 /**
2573 * Formulas don't need to be reset
2574 */
2575 void reset();
2576
2577 /**

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

2600 protected:
2601 Stat &s;
2602 mutable VResult vec;
2603 mutable VCounter cvec;
2604
2605 public:
2606 FormulaStatData(Stat &stat) : s(stat) {}
2607
2608 virtual bool zero() const { return s.zero(); }
2609 virtual void reset() { s.reset(); }
2610
2611 virtual size_t size() const { return s.size(); }
2612 virtual const VResult &result() const
2613 {
2614 s.result(vec);
2615 return vec;

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

2666 mutable VResult vec;
2667
2668 public:
2669 FormulaNode(const Formula &f) : formula(f) {}
2670
2671 virtual size_t size() const { return formula.size(); }
2672 virtual const VResult &result() const { formula.result(vec); return vec; }
2673 virtual Result total() const { return formula.total(); }
2674
2675 virtual std::string str() const { return formula.str(); }
2676};
2677
2678/**
2679 * Helper class to construct formula node trees.
2680 */
2681class Temp

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

2699 */
2700 operator NodePtr&() { return node;}
2701
2702 public:
2703 /**
2704 * Create a new ScalarStatNode.
2705 * @param s The ScalarStat to place in a node.
2706 */
2707 template <int N>
2708 Temp(const Scalar<N> &s)
2709 : node(new ScalarStatNode(s.statData())) { }
2710
2711 /**
2712 * Create a new ScalarStatNode.
2713 * @param s The ScalarStat to place in a node.
2714 */
2715 Temp(const Value &s)
2716 : node(new ScalarStatNode(s.statData())) { }
2717
2718 /**
2719 * Create a new ScalarStatNode.
2720 * @param s The ScalarStat to place in a node.
2721 */
2722 template <int N>
2723 Temp(const Average<N> &s)
2724 : node(new ScalarStatNode(s.statData())) { }
2725
2726 /**
2727 * Create a new VectorStatNode.
2728 * @param s The VectorStat to place in a node.
2729 */
2730 template <int N>
2731 Temp(const Vector<N> &s)
2732 : node(new VectorStatNode(s.statData())) { }
2733
2734 /**
2735 *
2736 */
2737 Temp(const Formula &f)
2738 : node(new FormulaNode(f)) { }
2739
2740 /**
2741 * Create a new ScalarProxyNode.
2742 * @param p The ScalarProxy to place in a node.
2743 */
2744 template <class Stat>
2745 Temp(const ScalarProxy<Stat> &p)
2746 : node(new ScalarProxyNode<Stat>(p)) { }
2747
2748 /**
2749 * Create a ConstNode
2750 * @param value The value of the const node.
2751 */
2752 Temp(signed char value)
2753 : node(new ConstNode<signed char>(value)) {}
2754

--- 133 unchanged lines hidden ---