#include "sim/host.hh"
//
-// Un-comment this to enable wierdo-stat debugging
+// Un-comment this to enable weirdo-stat debugging
//
// #define STAT_DEBUG
/** Print stats out in SS format. */
#define STAT_DISPLAY_COMPAT
+class Callback;
+
/** The current simulated cycle. */
extern Tick curTick;
* @param stream The stream to print to.
*/
virtual void display(std::ostream &stream) const = 0;
+ /**
+ * Reset this stat to the default state.
+ */
+ virtual void reset() = 0;
/**
* Return the number of entries in this stat.
* @return The number of entries.
*/
virtual bool zero() const = 0;
+ //need to document
+ virtual bool binned() const = 0;
/**
* Set the name and marks this stat to print at the end of simulation.
* @param stream The output stream.
*/
virtual void display(std::ostream &stream) const;
+
+ //need to document
+ virtual bool binned() const = 0;
};
void
* @param stream The output stream.
*/
virtual void display(std::ostream &stream) const;
+
+ //need to document
+ virtual bool binned() const = 0;
};
//////////////////////////////////////////////////////////////////////
* @return The value of this stat.
*/
T value(const Params &p) const { return data; }
+ /**
+ * Reset stat value to default
+ */
+ void reset() { data = T(); }
};
/**
* @return The current count.
*/
T value(const Params &p) const { return current; }
+ /**
+ * Reset stat value to default
+ */
+ void reset()
+ {
+ current = T();
+ total = 0;
+ last = curTick;
+ }
};
/**
* @return 1.
*/
virtual size_t size() const { return 1; }
+ virtual bool binned() const { return bin_t::binned; }
+
+ /**
+ * Reset stat value to default
+ */
+ void reset() { bin.reset(); }
};
//////////////////////////////////////////////////////////////////////
return *this;
}
+ /** Friend this class with the associated scalar proxy. */
friend class ScalarProxy<T, Storage, Bin>;
/**
* @return The size of the vector.
*/
virtual size_t size() const { return bin.size(); }
+ virtual bool binned() const { return bin_t::binned; }
+ /**
+ * Reset stat value to default
+ */
+ virtual void reset() { bin.reset(); }
};
/**
* @return 1.
*/
virtual size_t size() const { return 1; }
+ virtual bool binned() const { return false; }
+ /**
+ * This stat has no state. Nothing to reset
+ */
+ virtual void reset() { }
};
template <typename T, template <typename T> class Storage, class Bin>
virtual size_t size() const { return bin.size(); }
virtual bool zero() const { return data(0)->value(params) == 0.0; }
+ virtual bool binned() const { return bin_t::binned; }
virtual void
display(std::ostream &out) const
}
}
+ /**
+ * Reset stat value to default
+ */
+ virtual void reset() { bin.reset(); }
};
template <typename T, template <typename T> class Storage, class Bin>
assert (index >= 0 && index < size());
return ScalarProxy<T, Storage, Bin>(*bin, *params, offset + index);
}
+ virtual bool binned() const { return false; }
+
+ /**
+ * This stat has no state. Nothing to reset.
+ */
+ virtual void reset() { }
};
template <typename T, template <typename T> class Storage, class Bin>
*/
DistStor(const Params ¶ms)
: min_val(INT_MAX), max_val(INT_MIN), underflow(0), overflow(0),
- vec(params.size) {
+ vec(params.size)
+ {
+ reset();
}
+
/**
* Add a value to the distribution for the given number of times.
* @param val The value to add.
rvec, params.min, params.max, params.bucket_size,
params.size);
}
+ /**
+ * Reset stat value to default
+ */
+ void reset()
+ {
+ min_val = INT_MAX;
+ max_val = INT_MIN;
+ underflow = 0;
+ overflow = 0;
+
+ int size = vec.size();
+ for (int i = 0; i < size; ++i)
+ vec[i] = T();
+ }
+
};
void FancyDisplay(std::ostream &stream, const std::string &name,
/**
* Create and initialize this storage.
*/
- FancyStor(const Params &) : sum(0), squares(0), total(0) {}
+ FancyStor(const Params &) : sum(T()), squares(T()), total(0) {}
/**
* Add a value the given number of times to this running average.
* @return True if no samples have been added.
*/
bool zero(const Params &) const { return total == 0; }
+ /**
+ * Reset stat value to default
+ */
+ virtual void reset()
+ {
+ sum = T();
+ squares = T();
+ total = 0;
+ }
};
/**
/**
* Create and initialize this storage.
*/
- AvgFancy(const Params &) : sum(0), squares(0) {}
+ AvgFancy(const Params &) : sum(T()), squares(T()) {}
/**
* Add a value to the distribution for the given number of times.
* @return True if the sum is zero.
*/
bool zero(const Params ¶ms) const { return sum == 0; }
+ /**
+ * Reset stat value to default
+ */
+ virtual void reset()
+ {
+ sum = T();
+ squares = T();
+ }
};
/**
data()->display(stream, myname(), mydesc(), myprecision(), myflags(),
params);
}
+
+ virtual bool binned() const { return bin_t::binned; }
+ /**
+ * Reset stat value to default
+ */
+ virtual void reset()
+ {
+ bin.reset();
+ }
};
template <typename T, template <typename T> class Storage, class Bin>
-class VectorDistProxy;
+class DistProxy;
template <typename T, template <typename T> class Storage, class Bin>
class VectorDistBase : public Stat
VectorDistBase() : Stat(true) { }
~VectorDistBase() { }
- friend class VectorDistProxy<T, Storage, Bin>;
- VectorDistProxy<T, Storage, Bin> operator[](int index);
- const VectorDistProxy<T, Storage, Bin> operator[](int index) const;
+ friend class DistProxy<T, Storage, Bin>;
+ DistProxy<T, Storage, Bin> operator[](int index);
+ const DistProxy<T, Storage, Bin> operator[](int index) const;
virtual size_t size() const { return bin.size(); }
virtual bool zero() const { return false; }
virtual void display(std::ostream &stream) const;
+ virtual bool binned() const { return bin_t::binned; }
+ /**
+ * Reset stat value to default
+ */
+ virtual void reset()
+ {
+ bin.reset();
+ }
};
template <typename T, template <typename T> class Storage, class Bin>
-class VectorDistProxy : public Stat
+class DistProxy : public Stat
{
protected:
typedef Storage<T> storage_t;
const storage_t *data() const { return cstat->data(index); }
public:
- VectorDistProxy(const VectorDistBase<T, Storage, Bin> &s, int i)
+ DistProxy(const VectorDistBase<T, Storage, Bin> &s, int i)
: Stat(false), cstat(&s), index(i) {}
- VectorDistProxy(const VectorDistProxy &sp)
+ DistProxy(const DistProxy &sp)
: Stat(false), cstat(sp.cstat), index(sp.index) {}
- const VectorDistProxy &operator=(const VectorDistProxy &sp) {
+ const DistProxy &operator=(const DistProxy &sp) {
cstat = sp.cstat; index = sp.index; return *this;
}
data()->display(stream, name.str(), desc.str(),
cstat->myprecision(), cstat->myflags(), cstat->params);
}
+
+ virtual bool binned() const { return false; }
+ /**
+ * Proxy has no state. Nothing to reset.
+ */
+ virtual void reset() { }
};
template <typename T, template <typename T> class Storage, class Bin>
-inline VectorDistProxy<T, Storage, Bin>
+inline DistProxy<T, Storage, Bin>
VectorDistBase<T, Storage, Bin>::operator[](int index)
{
assert (index >= 0 && index < size());
- return VectorDistProxy<T, Storage, Bin>(*this, index);
+ return DistProxy<T, Storage, Bin>(*this, index);
}
template <typename T, template <typename T> class Storage, class Bin>
-inline const VectorDistProxy<T, Storage, Bin>
+inline const DistProxy<T, Storage, Bin>
VectorDistBase<T, Storage, Bin>::operator[](int index) const
{
assert (index >= 0 && index < size());
- return VectorDistProxy<T, Storage, Bin>(*this, index);
+ return DistProxy<T, Storage, Bin>(*this, index);
}
/**
VectorDistBase<T, Storage, Bin>::display(std::ostream &stream) const
{
for (int i = 0; i < size(); ++i) {
- VectorDistProxy<T, Storage, Bin> proxy(*this, i);
+ DistProxy<T, Storage, Bin> proxy(*this, i);
proxy.display(stream);
}
}
* @return The total of the result vector.
*/
virtual result_t total() const = 0;
+
+ virtual bool binned() const = 0;
};
/** Reference counting pointer to a function Node. */
virtual result_t total() const { return stat.val(); };
virtual size_t size() const { return 1; }
+
+ virtual bool binned() const { return stat.binned(); }
};
template <typename T, template <typename T> class Storage, class Bin>
virtual result_t total() const { return proxy.val(); };
virtual size_t size() const { return 1; }
+
+ virtual bool binned() const { return proxy.binned(); }
};
class VectorStatNode : public Node
virtual result_t total() const { return stat.total(); };
virtual size_t size() const { return stat.size(); }
+
+ virtual bool binned() const { return stat.binned(); }
};
template <typename T>
virtual result_t total() const { return data[0]; };
virtual size_t size() const { return 1; }
+ virtual bool binned() const { return false; }
};
template <typename T>
virtual result_t total() const { return (result_t)functor(); };
virtual size_t size() const { return 1; }
+ virtual bool binned() const { return false; }
};
template <typename T>
virtual result_t total() const { return (result_t)scalar; };
virtual size_t size() const { return 1; }
+ virtual bool binned() const { return false; }
};
template <class Op>
}
virtual size_t size() const { return l->size(); }
+ virtual bool binned() const { return l->binned(); }
};
template <class Op>
return ls;
}
}
+
+ virtual bool binned() const { return (l->binned() || r->binned()); }
};
template <class Op>
}
virtual size_t size() const { return 1; }
+ virtual bool binned() const { return l->binned(); }
};
/**
public:
BinBase(size_t size);
- ~BinBase();
+ virtual ~BinBase();
+ virtual void activate() = 0;
+ void regBin(BinBase *bin, std::string name);
};
} // namespace Detail
template <class BinType>
struct StatBin : public Detail::BinBase
{
+ private:
+ std::string _name;
+
+ public:
+ std::string name() const { return _name;}
+
static StatBin *&curBin() {
static StatBin *current = NULL;
return current;
return off;
}
- explicit StatBin(size_t size = 1024) : Detail::BinBase(size) {}
+ explicit StatBin(std::string name, size_t size = 1024) : Detail::BinBase(size) { _name = name; this->regBin(this, name); }
char *memory(off_t off) {
assert(offset() <= size());
return Detail::BinBase::memory() + off;
}
+ virtual void activate() { setCurBin(this); }
static void activate(StatBin &bin) { setCurBin(&bin); }
class BinBase
typedef typename Storage::Params Params;
public:
+ enum { binned = true };
Bin() { allocate(sizeof(Storage)); }
bool initialized() const { return true; }
void init(const Params ¶ms) { }
}
return reinterpret_cast<Storage *>(ptr);
}
+ void reset()
+ {
+ char *ptr = access();
+ char *flags = ptr + size() * sizeof(Storage);
+ if (!(*flags & 0x1))
+ return;
+
+ Storage *s = reinterpret_cast<Storage *>(ptr);
+ s->reset();
+ }
};
template <class Storage>
}
return reinterpret_cast<Storage *>(ptr + index * sizeof(Storage));
}
+ void reset()
+ {
+ char *ptr = access();
+ char *flags = ptr + size() * sizeof(Storage);
+ if (!(*flags & 0x1))
+ return;
+
+ for (int i = 0; i < _size; ++i) {
+ char *p = ptr + i * sizeof(Storage);
+ Storage *s = reinterpret_cast<Storage *>(p);
+ s->reset();
+ }
+ }
};
};
{
public:
typedef typename Storage::Params Params;
+ enum { binned = false };
private:
char ptr[sizeof(Storage)];
public:
+ ~Bin()
+ {
+ reinterpret_cast<Storage *>(ptr)->~Storage();
+ }
+
bool initialized() const { return true; }
void init(const Params ¶ms) {
new (ptr) Storage(params);
assert(initialized());
return reinterpret_cast<Storage *>(ptr);
}
+ void reset()
+ {
+ Storage *s = reinterpret_cast<Storage *>(ptr);
+ s->reset();
+ }
};
template <class Storage>
{
public:
typedef typename Storage::Params Params;
+ enum { binned = false };
private:
char *ptr;
public:
VectorBin() : ptr(NULL) { }
- ~VectorBin() {
- if (initialized())
- delete [] ptr;
+ ~VectorBin()
+ {
+ if (!initialized())
+ return;
+
+ for (int i = 0; i < _size; ++i) {
+ char *p = ptr + i * sizeof(Storage);
+ reinterpret_cast<Storage *>(p)->~Storage();
+ }
+ delete [] ptr;
}
+
bool initialized() const { return ptr != NULL; }
void init(int s, const Params ¶ms) {
assert(s > 0 && "size must be positive!");
assert(index >= 0 && index < size());
return reinterpret_cast<Storage *>(ptr + index * sizeof(Storage));
}
+ void reset()
+ {
+ for (int i = 0; i < _size; ++i) {
+ char *p = ptr + i * sizeof(Storage);
+ Storage *s = reinterpret_cast<Storage *>(p);
+ s->reset();
+ }
+ }
};
};
}
/**
- * Return the vector of values of this formula.
+ * Return the result of the Fomula in a vector. If there were no Vector
+ * components to the Formula, then the vector is size 1. If there were,
+ * like x/y with x being a vector of size 3, then the result returned will
+ * be x[0]/y, x[1]/y, x[2]/y, respectively.
* @return The result vector.
*/
const rvec_t &val() const { return root->val(); }
/**
- * Return the total of the result vector.
+ * Return the total Formula result. If there is a Vector component to this
+ * Formula, then this is the result of the Formula if the formula is applied
+ * after summing all the components of the Vector. For example, if Formula
+ * is x/y where x is size 3, then total() will return (x[1]+x[2]+x[3])/y. If there is no
+ * Vector component, total() returns the same value as the first entry in the rvec_t
+ * val() returns.
* @return The total of the result vector.
*/
result_t total() const { return root->total(); }
else
return root->size();
}
+
+ virtual bool binned() const { return root->binned(); }
+
+ /**
+ * Formulas don't need to be reset
+ */
+ virtual void reset() {}
};
/**
void check();
void dump(std::ostream &stream);
+void reset();
+void regReset(Callback *cb);
inline Detail::Temp
operator+(Detail::Temp l, Detail::Temp r)
projects / gem5.git / blobdiff