*
* Generalized N-dimensinal vector
* documentation
-* fix AvgStor
* key stats
* interval stats
* -- these both can use the same function that prints out a
public:
/**
- * Create this stat and register it if reg is true.
- * @param reg Register this stat in the database?
+ * Create this stat and perhaps register it with the stat database. To be
+ * printed a stat must be registered with the database.
+ * @param reg If true, register this stat in the database.
*/
Stat(bool reg);
/**
#endif
};
-// Scalar stats involved in formulas
+/**
+ * Base class for all scalar stats. The class provides an interface to access
+ * the current value of the stat. This class can be used in formulas.
+ */
class ScalarStat : public Stat
{
public:
+ /**
+ * Create and perhaps register this stat with the database.
+ * @param reg If true, register this stat with the database.
+ */
ScalarStat(bool reg) : Stat(reg) {}
+ /**
+ * Return the current value of this statistic as a result type.
+ * @return The current value of this statistic.
+ */
virtual result_t val() const = 0;
+ /**
+ * Return true if this stat has value zero.
+ * @return True if this stat is zero.
+ */
virtual bool zero() const;
+ /**
+ * Print this stat to the provided ostream.
+ * @param stream The output stream.
+ */
virtual void display(std::ostream &stream) const;
};
int myprecision, FormatFlags myflags, const rvec_t &vec,
result_t mytotal);
-// Vector stats involved in formulas
+/**
+ * Base class for all vector stats. This class provides interfaces to access
+ * the current values of the stats as well as the totals. This class can be
+ * used in formulas.
+ */
class VectorStat : public Stat
{
public:
+ /**
+ * Create and perhaps register this stat with the database.
+ * @param reg If true, register this stat with the database.
+ */
VectorStat(bool reg) : Stat(reg) {}
+ /**
+ * Return a vector of result typesd of all the values in the vector.
+ * @return The values of the vector.
+ */
virtual const rvec_t &val() const = 0;
+ /**
+ * Return the total of all the entries in the vector.
+ * @return The total of the vector.
+ */
virtual result_t total() const = 0;
+ /**
+ * Return true if this stat has value zero.
+ * @return True if this stat is zero.
+ */
virtual bool zero() const;
+ /**
+ * Print this stat to the provided ostream.
+ * @param stream The output stream.
+ */
virtual void display(std::ostream &stream) const;
};
// Simple Statistics
//
//////////////////////////////////////////////////////////////////////
+
+/**
+ * Templatized storage and interface for a simple scalar stat.
+ */
template <typename T>
struct StatStor
{
public:
+ /** The paramaters for this storage type, none for a scalar. */
struct Params { };
private:
+ /** The statistic value. */
T data;
public:
+ /**
+ * Builds this storage element and calls the base constructor of the
+ * datatype.
+ */
StatStor(const Params &) : data(T()) {}
+ /**
+ * The the stat to the given value.
+ * @param val The new value.
+ * @param p The paramters of this storage type.
+ */
void set(T val, const Params &p) { data = val; }
+ /**
+ * Increment the stat by the given value.
+ * @param val The new value.
+ * @param p The paramters of this storage type.
+ */
void inc(T val, const Params &p) { data += val; }
+ /**
+ * Decrement the stat by the given value.
+ * @param val The new value.
+ * @param p The paramters of this storage type.
+ */
void dec(T val, const Params &p) { data -= val; }
+ /**
+ * Return the value of this stat as a result type.
+ * @param p The parameters of this storage type.
+ * @return The value of this stat.
+ */
result_t val(const Params &p) const { return (result_t)data; }
+ /**
+ * Return the value of this stat as its base type.
+ * @param p The params of this storage type.
+ * @return The value of this stat.
+ */
T value(const Params &p) const { return data; }
};
+/**
+ * Templatized storage and interface to a per-cycle average stat. This keeps
+ * a current count and updates a total (count * cycles) when this count
+ * changes. This allows the quick calculation of a per cycle count of the item
+ * being watched. This is good for keeping track of residencies in structures
+ * among other things.
+ * @todo add lateny to the stat and fix binning.
+ */
template <typename T>
struct AvgStor
{
public:
+ /** The paramaters for this storage type, none for this average. */
struct Params { };
private:
+ /** The current count. */
T current;
+ /** The total count for all cycles. */
mutable result_t total;
+ /** The cycle that current last changed. */
mutable Tick last;
public:
+ /**
+ * Build and initializes this stat storage.
+ */
AvgStor(const Params &) : current(T()), total(0), last(0) { }
+ /**
+ * Set the current count to the one provided, update the total and last
+ * set values.
+ * @param val The new count.
+ * @param p The parameters for this storage.
+ */
void set(T val, const Params &p) {
total += current * (curTick - last);
last = curTick;
current = val;
}
+ /**
+ * Increment the current count by the provided value, calls set.
+ * @param val The amount to increment.
+ * @param p The parameters for this storage.
+ */
void inc(T val, const Params &p) { set(current + val, p); }
+ /**
+ * Deccrement the current count by the provided value, calls set.
+ * @param val The amount to decrement.
+ * @param p The parameters for this storage.
+ */
void dec(T val, const Params &p) { set(current - val, p); }
+ /**
+ * Return the current average.
+ * @param p The parameters for this storage.
+ * @return The current average.
+ */
result_t val(const Params &p) const {
total += current * (curTick - last);
last = curTick;
return (result_t)(total + current) / (result_t)(curTick + 1);
}
+ /**
+ * Return the current count.
+ * @param p The parameters for this storage.
+ * @return The current count.
+ */
T value(const Params &p) const { return current; }
};
+/**
+ * Implementation of a scalar stat. The type of stat is determined by the
+ * Storage template. The storage for this stat is held within the Bin class.
+ * This allows for breaking down statistics across multiple bins easily.
+ */
template <typename T, template <typename T> class Storage, class Bin>
class ScalarBase : public ScalarStat
{
protected:
+ /** Define the type of the storage class. */
typedef Storage<T> storage_t;
+ /** Define the params of the storage class. */
typedef typename storage_t::Params params_t;
+ /** Define the bin type. */
typedef typename Bin::Bin<storage_t> bin_t;
protected:
+ /** The bin of this stat. */
bin_t bin;
+ /** The parameters for this stat. */
params_t params;
protected:
+ /**
+ * Retrieve the storage from the bin.
+ * @return The storage object for this stat.
+ */
storage_t *data() { return bin.data(params); }
+ /**
+ * Retrieve a const pointer to the storage from the bin.
+ * @return A const pointer to the storage object for this stat.
+ */
const storage_t *data() const {
return (const_cast<bin_t *>(&bin))->data(params);
}
protected:
- // Copying stats is not allowed
+ /**
+ * Copy constructor, copies are not allowed.
+ */
ScalarBase(const ScalarBase &stat);
+ /**
+ * Can't copy stats.
+ */
const ScalarBase &operator=(const ScalarBase &);
public:
+ /**
+ * Return the current value of this stat as a result type.
+ * @return The current value.
+ */
result_t val() const { return data()->val(params); }
+ /**
+ * Return the current value of this stat as its base type.
+ * @return The current value.
+ */
T value() const { return data()->value(params); }
public:
+ /**
+ * Create and initialize this stat, register it with the database.
+ */
ScalarBase() : ScalarStat(true) {
bin.init(params);
setInit();
public:
// Common operators for stats
+ /**
+ * Increment the stat by 1. This calls the associated storage object inc
+ * function.
+ */
void operator++() { data()->inc(1, params); }
+ /**
+ * Decrement the stat by 1. This calls the associated storage object dec
+ * function.
+ */
void operator--() { data()->dec(1, params); }
+ /** Increment the stat by 1. */
void operator++(int) { ++*this; }
+ /** Decrement the stat by 1. */
void operator--(int) { --*this; }
+ /**
+ * Set the data value to the given value. This calls the associated storage
+ * object set function.
+ * @param v The new value.
+ */
template <typename U>
void operator=(const U& v) { data()->set(v, params); }
+ /**
+ * Increment the stat by the given value. This calls the associated
+ * storage object inc function.
+ * @param v The value to add.
+ */
template <typename U>
void operator+=(const U& v) { data()->inc(v, params); }
+ /**
+ * Decrement the stat by the given value. This calls the associated
+ * storage object dec function.
+ * @param v The value to substract.
+ */
template <typename U>
void operator-=(const U& v) { data()->dec(v, params); }
+ /**
+ * Return the number of elements, always 1 for a scalar.
+ * @return 1.
+ */
virtual size_t size() const { return 1; }
};
template <typename T, template <typename T> class Storage, class Bin>
class ScalarProxy;
+/**
+ * Implementation of a vector of stats. The type of stat is determined by the
+ * Storage class. @sa ScalarBase
+ */
template <typename T, template <typename T> class Storage, class Bin>
class VectorBase : public VectorStat
{
protected:
+ /** Define the type of the storage class. */
typedef Storage<T> storage_t;
+ /** Define the params of the storage class. */
typedef typename storage_t::Params params_t;
+ /** Define the bin type. */
typedef typename Bin::VectorBin<storage_t> bin_t;
private:
+ /** Local storage for the entry values, used for printing. */
mutable rvec_t *vec;
protected:
+ /** The bin of this stat. */
bin_t bin;
+ /** The parameters for this stat. */
params_t params;
protected:
+ /**
+ * Retrieve the storage from the bin for the given index.
+ * @param index The vector index to access.
+ * @return The storage object at the given index.
+ */
storage_t *data(int index) { return bin.data(index, params); }
+ /**
+ * Retrieve a const pointer to the storage from the bin
+ * for the given index.
+ * @param index The vector index to access.
+ * @return A const pointer to the storage object at the given index.
+ */
const storage_t *data(int index) const {
return (const_cast<bin_t *>(&bin))->data(index, params);
}
protected:
// Copying stats is not allowed
+ /** Copying stats isn't allowed. */
VectorBase(const VectorBase &stat);
+ /** Copying stats isn't allowed. */
const VectorBase &operator=(const VectorBase &);
public:
+ /**
+ * Copy the values to a local vector and return a reference to it.
+ * @return A reference to a vector of the stat values.
+ */
const rvec_t &val() const {
if (vec)
vec->resize(size());
return *vec;
}
+ /**
+ * Return a total of all entries in this vector.
+ * @return The total of all vector entries.
+ */
result_t total() const {
result_t total = 0.0;
for (int i = 0; i < size(); ++i)
}
public:
+ /**
+ * Create this vector and register it with the database.
+ */
VectorBase() : VectorStat(true), vec(NULL) {}
+ /**
+ * Destructor.
+ */
~VectorBase() { if (vec) delete vec; }
+ /**
+ * Set this vector to have the given size.
+ * @param size The new size.
+ * @return A reference to this stat.
+ */
VectorBase &init(size_t size) {
bin.init(size, params);
setInit();
}
friend class ScalarProxy<T, Storage, Bin>;
+
+ /**
+ * Return a reference (ScalarProxy) to the stat at the given index.
+ * @param index The vector index to access.
+ * @return A reference of the stat.
+ */
ScalarProxy<T, Storage, Bin> operator[](int index);
+ /**
+ * Return the number of elements in this vector.
+ * @return The size of the vector.
+ */
virtual size_t size() const { return bin.size(); }
};
+/**
+ * A proxy class to access the stat at a given index in a VectorBase stat.
+ * Behaves like a ScalarBase.
+ */
template <typename T, template <typename T> class Storage, class Bin>
class ScalarProxy : public ScalarStat
{
protected:
+ /** Define the type of the storage class. */
typedef Storage<T> storage_t;
+ /** Define the params of the storage class. */
typedef typename storage_t::Params params_t;
+ /** Define the bin type. */
typedef typename Bin::VectorBin<storage_t> bin_t;
private:
+ /** Pointer to the bin in the parent VectorBase. */
bin_t *bin;
+ /** Pointer to the params in the parent VectorBase. */
params_t *params;
+ /** The index to access in the parent VectorBase. */
int index;
protected:
+ /**
+ * Retrieve the storage from the bin.
+ * @return The storage from the bin for this stat.
+ */
storage_t *data() { return bin->data(index, *params); }
+ /**
+ * Retrieve a const pointer to the storage from the bin.
+ * @return A const pointer to the storage for this stat.
+ */
const storage_t *data() const { return bin->data(index, *params); }
public:
+ /**
+ * Return the current value of this statas a result type.
+ * @return The current value.
+ */
result_t val() const { return data()->val(*params); }
+ /**
+ * Return the current value of this stat as its base type.
+ * @return The current value.
+ */
T value() const { return data()->value(*params); }
public:
+ /**
+ * Create and initialize this proxy, do not register it with the database.
+ * @param b The bin to use.
+ * @param p The params to use.
+ * @param i The index to access.
+ */
ScalarProxy(bin_t &b, params_t &p, int i)
: ScalarStat(false), bin(&b), params(&p), index(i) {}
+ /**
+ * Create a copy of the provided ScalarProxy.
+ * @param sp The proxy to copy.
+ */
ScalarProxy(const ScalarProxy &sp)
: ScalarStat(false), bin(sp.bin), params(sp.params), index(sp.index) {}
+ /**
+ * Set this proxy equal to the provided one.
+ * @param sp The proxy to copy.
+ * @return A reference to this proxy.
+ */
const ScalarProxy &operator=(const ScalarProxy &sp) {
bin = sp.bin;
params = sp.params;
public:
// Common operators for stats
+ /**
+ * Increment the stat by 1. This calls the associated storage object inc
+ * function.
+ */
void operator++() { data()->inc(1, *params); }
+ /**
+ * Decrement the stat by 1. This calls the associated storage object dec
+ * function.
+ */
void operator--() { data()->dec(1, *params); }
+ /** Increment the stat by 1. */
void operator++(int) { ++*this; }
+ /** Decrement the stat by 1. */
void operator--(int) { --*this; }
+ /**
+ * Set the data value to the given value. This calls the associated storage
+ * object set function.
+ * @param v The new value.
+ */
template <typename U>
void operator=(const U& v) { data()->set(v, *params); }
+ /**
+ * Increment the stat by the given value. This calls the associated
+ * storage object inc function.
+ * @param v The value to add.
+ */
template <typename U>
void operator+=(const U& v) { data()->inc(v, *params); }
+ /**
+ * Decrement the stat by the given value. This calls the associated
+ * storage object dec function.
+ * @param v The value to substract.
+ */
template <typename U>
void operator-=(const U& v) { data()->dec(v, *params); }
+ /**
+ * Return the number of elements, always 1 for a scalar.
+ * @return 1.
+ */
virtual size_t size() const { return 1; }
};
}
/**
- * This makes the assumption that if you're gonna subnames a 2d vector,
- * you're subnaming across all y
+ * @warning This makes the assumption that if you're gonna subnames a 2d
+ * vector, you're subnaming across all y
*/
Vector2dBase &ysubnames(const char **names)
{
result_t underflow, result_t overflow,
const rvec_t &vec, int min, int max, int bucket_size,
int size);
-
+/**
+ * Templatized storage and interface for a distrbution stat.
+ */
template <typename T>
struct DistStor
{
public:
+ /** The parameters for a distribution stat. */
struct Params
{
+ /** The minimum value to track. */
int min;
+ /** The maximum value to track. */
int max;
+ /** The number of entries in each bucket. */
int bucket_size;
+ /** The number of buckets. Equal to (max-min)/bucket_size. */
int size;
};
private:
+ /** The smallest value sampled. */
T min_val;
+ /** The largest value sampled. */
T max_val;
+ /** The number of values sampled less than min. */
T underflow;
+ /** The number of values sampled more than max. */
T overflow;
+ /** Counter for each bucket. */
std::vector<T> vec;
public:
+ /**
+ * Construct this storage with the supplied params.
+ * @param params The parameters.
+ */
DistStor(const Params ¶ms)
: min_val(INT_MAX), max_val(INT_MIN), underflow(0), overflow(0),
vec(params.size) {
}
+ /**
+ * Add a value to the distribution for the given number of times.
+ * @param val The value to add.
+ * @param number The number of times to add the value.
+ * @param params The paramters of the distribution.
+ */
void sample(T val, int number, const Params ¶ms) {
if (val < params.min)
underflow += number;
max_val = val;
}
+ /**
+ * Return the number of buckets in this distribution.
+ * @return the number of buckets.
+ * @todo Is it faster to return the size from the parameters?
+ */
size_t size(const Params &) const { return vec.size(); }
+ /**
+ * Returns true if any calls to sample have been made.
+ * @param params The paramters of the distribution.
+ * @return True if any values have been sampled.
+ */
bool zero(const Params ¶ms) const {
if (underflow != 0 || overflow != 0)
- return true;
+ return false;
int s = size(params);
for (int i = 0; i < s; i++)
if (vec[i] != 0)
- return true;
+ return false;
- return false;
+ return true;
}
+ /**
+ * Print this distribution and the given print data to the given ostream.
+ * @param stream The output stream.
+ * @param name The name of this stat (from StatData).
+ * @param desc The description of this stat (from StatData).
+ * @param precision The print precision (from StatData).
+ * @param flags The format flags (from StatData).
+ * @param params The paramters of this distribution.
+ */
void display(std::ostream &stream, const std::string &name,
const std::string &desc, int precision, FormatFlags flags,
const Params ¶ms) const {
void FancyDisplay(std::ostream &stream, const std::string &name,
const std::string &desc, int precision, FormatFlags flags,
result_t mean, result_t variance);
+
+/**
+ * Templatized storage and interface for a distribution that calculates mean
+ * and variance.
+ */
template <typename T>
struct FancyStor
{
public:
+ /**
+ * No paramters for this storage.
+ */
struct Params {};
private:
+ /** The current sum. */
T sum;
+ /** The sum of squares. */
T squares;
+ /** The total number of samples. */
int total;
public:
+ /**
+ * Create and initialize this storage.
+ */
FancyStor(const Params &) : sum(0), squares(0), total(0) {}
- void sample(T val, int number, const Params &) {
+ /**
+ * Add a value the given number of times to this running average.
+ * Update the running sum and sum of squares, increment the number of
+ * values seen by the given number.
+ * @param val The value to add.
+ * @param number The number of times to add the value.
+ * @param p The parameters of this stat.
+ */
+ void sample(T val, int number, const Params &p) {
T value = val * number;
sum += value;
squares += value * value;
total += number;
}
+
+ /**
+ * Print this distribution and the given print data to the given ostream.
+ * @param stream The output stream.
+ * @param name The name of this stat (from StatData).
+ * @param desc The description of this stat (from StatData).
+ * @param precision The print precision (from StatData).
+ * @param flags The format flags (from StatData).
+ * @param params The paramters of this distribution.
+ */
void display(std::ostream &stream, const std::string &name,
const std::string &desc, int precision, FormatFlags flags,
- const Params &) const {
+ const Params ¶ms) const {
result_t mean = NAN;
result_t variance = NAN;
FancyDisplay(stream, name, desc, precision, flags, mean, variance);
}
+ /**
+ * Return the number of entries in this stat, 1
+ * @return 1.
+ */
size_t size(const Params &) const { return 1; }
+ /**
+ * Return true if no samples have been added.
+ * @return True if no samples have been added.
+ */
bool zero(const Params &) const { return total == 0; }
};
+/**
+ * Templatized storage for distribution that calculates per cycle mean and
+ * variance.
+ */
template <typename T>
struct AvgFancy
{
public:
+ /** No parameters for this storage. */
struct Params {};
private:
+ /** Current total. */
T sum;
+ /** Current sum of squares. */
T squares;
public:
+ /**
+ * Create and initialize this storage.
+ */
AvgFancy(const Params &) : sum(0), squares(0) {}
+ /**
+ * Add a value to the distribution for the given number of times.
+ * Update the running sum and sum of squares.
+ * @param val The value to add.
+ * @param number The number of times to add the value.
+ * @param p The paramters of the distribution.
+ */
void sample(T val, int number, const Params& p) {
T value = val * number;
sum += value;
squares += value * value;
}
+
+ /**
+ * Print this distribution and the given print data to the given ostream.
+ * @param stream The output stream.
+ * @param name The name of this stat (from StatData).
+ * @param desc The description of this stat (from StatData).
+ * @param precision The print precision (from StatData).
+ * @param flags The format flags (from StatData).
+ * @param params The paramters of this distribution.
+ */
void display(std::ostream &stream, const std::string &name,
const std::string &desc, int precision, FormatFlags flags,
const Params ¶ms) const {
FancyDisplay(stream, name, desc, precision, flags, mean, variance);
}
+ /**
+ * Return the number of entries, in this case 1.
+ * @return 1.
+ */
size_t size(const Params ¶ms) const { return 1; }
+ /**
+ * Return true if no samples have been added.
+ * @return True if the sum is zero.
+ */
bool zero(const Params ¶ms) const { return sum == 0; }
};
+/**
+ * Implementation of a distribution stat. The type of distribution is
+ * determined by the Storage template. @sa ScalarBase
+ */
template <typename T, template <typename T> class Storage, class Bin>
class DistBase : public Stat
{
protected:
+ /** Define the type of the storage class. */
typedef Storage<T> storage_t;
+ /** Define the params of the storage class. */
typedef typename storage_t::Params params_t;
+ /** Define the bin type. */
typedef typename Bin::Bin<storage_t> bin_t;
protected:
+ /** The bin of this stat. */
bin_t bin;
+ /** The parameters for this stat. */
params_t params;
protected:
+ /**
+ * Retrieve the storage from the bin.
+ * @return The storage object for this stat.
+ */
storage_t *data() { return bin.data(params); }
+ /**
+ * Retrieve a const pointer to the storage from the bin.
+ * @return A const pointer to the storage object for this stat.
+ */
const storage_t *data() const {
return (const_cast<bin_t *>(&bin))->data(params);
}
protected:
// Copying stats is not allowed
+ /** Copies are not allowed. */
DistBase(const DistBase &stat);
+ /** Copies are not allowed. */
const DistBase &operator=(const DistBase &);
public:
+ /**
+ * Create this distrubition and register it with the database.
+ */
DistBase() : Stat(true) { }
+ /**
+ * Destructor.
+ */
~DistBase() { }
+ /**
+ * Add a value to the distribtion n times. Calls sample on the storage
+ * class.
+ * @param v The value to add.
+ * @param n The number of times to add it, defaults to 1.
+ */
template <typename U>
void sample(const U& v, int n = 1) { data()->sample(v, n, params); }
+ /**
+ * Return the number of entries in this stat.
+ * @return The number of entries.
+ */
virtual size_t size() const { return data()->size(params); }
+ /**
+ * Return true if no samples have been added.
+ * @return True if there haven't been any samples.
+ */
virtual bool zero() const { return data()->zero(params); }
+ /**
+ * Print this distribution to the given ostream.
+ * @param stream The output stream.
+ */
virtual void display(std::ostream &stream) const {
data()->display(stream, myname(), mydesc(), myprecision(), myflags(),
params);
// Formula Details
//
//////////////////////////////////////////////////////////////////////
+
+/**
+ * Base class for formula statistic node. These nodes are used to build a tree
+ * that represents the formula.
+ */
class Node : public RefCounted
{
public:
+ /**
+ * Return the number of nodes in the subtree starting at this node.
+ * @return the number of nodes in this subtree.
+ */
virtual size_t size() const = 0;
+ /**
+ * Return the result vector of this subtree.
+ * @return The result vector of this subtree.
+ */
virtual const rvec_t &val() const = 0;
+ /**
+ * Return the total of the result vector.
+ * @return The total of the result vector.
+ */
virtual result_t total() const = 0;
};
+/** Reference counting pointer to a function Node. */
typedef RefCountingPtr<Node> NodePtr;
class ScalarStatNode : public Node
virtual size_t size() const { return 1; }
};
+/**
+ * Helper class to construct formula node trees.
+ */
class Temp
{
private:
+ /**
+ * Pointer to a Node object.
+ */
NodePtr node;
public:
+ /**
+ * Copy the given pointer to this class.
+ * @param n A pointer to a Node object to copy.
+ */
Temp(NodePtr n) : node(n) {}
+ /**
+ * Create a new ScalarStatNode.
+ * @param s The ScalarStat to place in a node.
+ */
Temp(const ScalarStat &s) : node(new ScalarStatNode(s)) {}
+ /**
+ * Create a new ScalarProxyNode.
+ * @param p The ScalarProxy to place in a node.
+ */
template <typename T, template <typename T> class Storage, class Bin>
Temp(const ScalarProxy<T, Storage, Bin> &p)
: node(new ScalarProxyNode<T, Storage, Bin>(p)) {}
+ /**
+ * Create a new VectorStatNode.
+ * @param s The VectorStat to place in a node.
+ */
Temp(const VectorStat &s) : node(new VectorStatNode(s)) {}
-#define TempSCALAR(T) \
- Temp(T value) : node(new ConstNode<T>(value)) {}
-
- TempSCALAR( signed char);
- TempSCALAR(unsigned char);
- TempSCALAR( signed short);
- TempSCALAR(unsigned short);
- TempSCALAR( signed int);
- TempSCALAR(unsigned int);
- TempSCALAR( signed long);
- TempSCALAR(unsigned long);
- TempSCALAR( signed long long);
- TempSCALAR(unsigned long long);
- TempSCALAR(float);
- TempSCALAR(double);
-#undef TempSCALAR
+ /**
+ * Create a ConstNode
+ * @param value The value of the const node.
+ */
+ Temp(signed char value) : node(new ConstNode<signed char>(value)) {}
+ /**
+ * Create a ConstNode
+ * @param value The value of the const node.
+ */
+ Temp(unsigned char value) : node(new ConstNode<unsigned char>(value)) {}
+ /**
+ * Create a ConstNode
+ * @param value The value of the const node.
+ */
+ Temp(signed short value) : node(new ConstNode<signed short>(value)) {}
+ /**
+ * Create a ConstNode
+ * @param value The value of the const node.
+ */
+ Temp(unsigned short value) : node(new ConstNode<unsigned short>(value)) {}
+ /**
+ * Create a ConstNode
+ * @param value The value of the const node.
+ */
+ Temp(signed int value) : node(new ConstNode<signed int>(value)) {}
+ /**
+ * Create a ConstNode
+ * @param value The value of the const node.
+ */
+ Temp(unsigned int value) : node(new ConstNode<unsigned int>(value)) {}
+ /**
+ * Create a ConstNode
+ * @param value The value of the const node.
+ */
+ Temp(signed long value) : node(new ConstNode<signed long>(value)) {}
+ /**
+ * Create a ConstNode
+ * @param value The value of the const node.
+ */
+ Temp(unsigned long value) : node(new ConstNode<unsigned long>(value)) {}
+ /**
+ * Create a ConstNode
+ * @param value The value of the const node.
+ */
+ Temp(signed long long value)
+ : node(new ConstNode<signed long long>(value)) {}
+ /**
+ * Create a ConstNode
+ * @param value The value of the const node.
+ */
+ Temp(unsigned long long value)
+ : node(new ConstNode<unsigned long long>(value)) {}
+ /**
+ * Create a ConstNode
+ * @param value The value of the const node.
+ */
+ Temp(float value) : node(new ConstNode<float>(value)) {}
+ /**
+ * Create a ConstNode
+ * @param value The value of the const node.
+ */
+ Temp(double value) : node(new ConstNode<double>(value)) {}
+ /**
+ * Return the node pointer.
+ * @return the node pointer.
+ */
operator NodePtr() { return node;}
};
// Visible Statistics Types
//
//////////////////////////////////////////////////////////////////////
-/**@defgroup VStats VisibleStatTypes
+/**
+ * @defgroup VisibleStats "Statistic Types"
+ * These are the statistics that are used in the simulator. By default these
+ * store counters and don't use binning, but are templatized to accept any type
+ * and any Bin class.
+ * @{
*/
-/** @ingroup VStats
- *This is the simplest counting stat. Default type is Counter, but can be
- *anything (like double, int, etc). To bin, just designate the name of the bin
- * when declaring. It can be used like a regular Counter.
- *Example: Stat<> foo;
- *foo += num_foos;
+/**
+ * This is a simple scalar statistic, like a counter.
+ * @sa Stat, ScalarBase, StatStor
*/
template <typename T = Counter, class Bin = NoBin>
class Scalar : public Detail::ScalarBase<T, Detail::StatStor, Bin>
{
public:
+ /** The base implementation. */
typedef Detail::ScalarBase<T, Detail::StatStor, Bin> Base;
-/** sets Stat equal to value of type U */
+ /**
+ * Sets the stat equal to the given value. Calls the base implementation
+ * of operator=
+ * @param v The new value.
+ */
template <typename U>
void operator=(const U& v) { Base::operator=(v); }
};
-/** @ingroup VStats
- *This calculates averages over number of cycles. Additionally, the update per
- *cycle is implicit if there is no change. In other words, if you want to know
- *the average number of instructions in the IQ per cycle, then you can use this
- * stat and not have to update it on cycles where there is no change.
+/**
+ * A stat that calculates the per cycle average of a value.
+ * @sa Stat, ScalarBase, AvgStor
*/
template <typename T = Counter, class Bin = NoBin>
class Average : public Detail::ScalarBase<T, Detail::AvgStor, Bin>
{
public:
+ /** The base implementation. */
typedef Detail::ScalarBase<T, Detail::AvgStor, Bin> Base;
-/** sets Average equalt to value of type U*/
+ /**
+ * Sets the stat equal to the given value. Calls the base implementation
+ * of operator=
+ * @param v The new value.
+ */
template <typename U>
void operator=(const U& v) { Base::operator=(v); }
};
-/** @ingroup VStats
- *This is a vector of type T, ideally suited to track stats across something like
- * SMT threads.
+/**
+ * A vector of scalar stats.
+ * @sa Stat, VectorBase, StatStor
*/
template <typename T = Counter, class Bin = NoBin>
class Vector : public Detail::VectorBase<T, Detail::StatStor, Bin>
{ };
-/** @ingroup VStats
- *This is a vector of Averages of type T
+/**
+ * A vector of Average stats.
+ * @sa Stat, VectorBase, AvgStor
*/
template <typename T = Counter, class Bin = NoBin>
class AverageVector : public Detail::VectorBase<T, Detail::AvgStor, Bin>
{ };
-/** @ingroup VStats
- *This is a 2-dimensional vector. Intended usage is for something like tracking a
- * Vector stat across another Vector like SMT threads.
+/**
+ * A 2-Dimensional vecto of scalar stats.
+ * @sa Stat, Vector2dBase, StatStor
*/
template <typename T = Counter, class Bin = NoBin>
class Vector2d : public Detail::Vector2dBase<T, Detail::StatStor, Bin>
{ };
-/** @ingroup VStats
- * This is essentially a Vector, but with minor differences. Where a
- * Vector's index maps directly to what it's tracking, a Distribution's index can
- * map to an arbitrary bucket type. For example, you could map 1-8 to bucket 0
- * of a Distribution, and if ever there are 1-8 instructions within an IQ, increment
- * bucket 0.
+/**
+ * A simple distribution stat.
+ * @sa Stat, DistBase, DistStor
*/
template <typename T = Counter, class Bin = NoBin>
class Distribution : public Detail::DistBase<T, Detail::DistStor, Bin>
{
private:
+ /** Base implementation. */
typedef Detail::DistBase<T, Detail::DistStor, Bin> Base;
+ /** The Parameter type. */
typedef typename Detail::DistStor<T>::Params Params;
public:
/**
- *This must be called to set some data members of the distribution
- *as well as to allocate the appropriate storage size.
- *@param min The minimum value of the Distribution
- *@param max The maximum value of the Distribution (NOT the size!)
- *@param bkt The size of the buckets to indicate mapping. I.e. if you have
- *min=0, max=15, bkt=8, you will have two buckets, and anything from 0-7
- *will go into bucket 0, and anything from 8-15 be in bucket 1.
- *@return the Distribution itself.
+ * Set the parameters of this distribution. @sa DistStor::Params
+ * @param min The minimum value of the distribution.
+ * @param max The maximum value of the distribution.
+ * @param bkt The number of values in each bucket.
+ * @return A reference to this distribution.
*/
Distribution &init(T min, T max, int bkt) {
params.min = min;
}
};
-/** @ingroup VStats
- *This has the functionality of a standard deviation built into it. Update it
- *every cycle, and at the end you will have the standard deviation.
+/**
+ * Calculates the mean and variance of all the samples.
+ * @sa Stat, DistBase, FancyStor
*/
template <typename T = Counter, class Bin = NoBin>
class StandardDeviation : public Detail::DistBase<T, Detail::FancyStor, Bin>
{
private:
+ /** The base implementation */
typedef Detail::DistBase<T, Detail::DistStor, Bin> Base;
+ /** The parameter type. */
typedef typename Detail::DistStor<T>::Params Params;
public:
+ /**
+ * Construct and initialize this distribution.
+ */
StandardDeviation() {
bin.init(params);
setInit();
}
};
-/** @ingroup VStats
- *This also calculates standard deviations, but there is no need to
- *update every cycle if there is no change, the stat will update for you.
+/**
+ * Calculates the per cycle mean and variance of the samples.
+ * @sa Stat, DistBase, AvgFancy
*/
template <typename T = Counter, class Bin = NoBin>
class AverageDeviation : public Detail::DistBase<T, Detail::AvgFancy, Bin>
{
private:
+ /** The base implementation */
typedef Detail::DistBase<T, Detail::DistStor, Bin> Base;
+ /** The parameter type. */
typedef typename Detail::DistStor<T>::Params Params;
public:
+ /**
+ * Construct and initialize this distribution.
+ */
AverageDeviation() {
bin.init(params);
setInit();
}
};
-/** @ingroup VStats
- *This is a vector of Distributions. (The complexity increases!). Intended usage
- * is for something like tracking a distribution across a vector like SMT threads.
+/**
+ * A vector of distributions.
+ * @sa Stat, VectorDistBase, DistStor
*/
template <typename T = Counter, class Bin = NoBin>
class VectorDistribution
: public Detail::VectorDistBase<T, Detail::DistStor, Bin>
{
private:
+ /** The base implementation */
typedef Detail::VectorDistBase<T, Detail::DistStor, Bin> Base;
+ /** The parameter type. */
typedef typename Detail::DistStor<T>::Params Params;
public:
/**
- *This must be called to set some data members and allocate storage space.
- *@param size The size of the Vector
- *@param min The minumum value of the Distribution
- *@param max The maximum value of the Distribution (NOT the size)
- *@param bkt The range of the bucket. I.e if min=0, max=15, and bkt=8,
- *then 0-7 will be bucket 0, and 8-15 will be bucket 1.
- *@return return the VectorDistribution itself.
+ * Initialize storage and parameters for this distribution.
+ * @param size The size of the vector (the number of distributions).
+ * @param min The minimum value of the distribution.
+ * @param max The maximum value of the distribution.
+ * @param bkt The number of values in each bucket.
+ * @return A reference to this distribution.
*/
VectorDistribution &init(int size, T min, T max, int bkt) {
params.min = min;
}
};
-/** @ingroup VStats
- *This is a vector of Standard Deviations. Intended usage is for tracking
- *Standard Deviations across a vector like SMT threads.
+/**
+ * This is a vector of StandardDeviation stats.
+ * @sa Stat, VectorDistBase, FancyStor
*/
template <typename T = Counter, class Bin = NoBin>
class VectorStandardDeviation
: public Detail::VectorDistBase<T, Detail::FancyStor, Bin>
{
private:
+ /** The base implementation */
typedef Detail::VectorDistBase<T, Detail::FancyStor, Bin> Base;
+ /** The parameter type. */
typedef typename Detail::DistStor<T>::Params Params;
public:
- /** This must be called to initialize some data members and allocate
- * approprate storage space for the stat.
- *@param size The size of the Vector
- * @return the VectorStandardDeviation itself.
+ /**
+ * Initialize storage for this distribution.
+ * @param size The size of the vector.
+ * @return A reference to this distribution.
*/
VectorStandardDeviation &init(int size) {
bin.init(size, params);
}
};
-/** @ingroup VStats
- * This is a vector of Average Deviations. Intended usage is for tracking
- *Average Deviations across a vector like SMT threads.
+/**
+ * This is a vector of AverageDeviation stats.
+ * @sa Stat, VectorDistBase, AvgFancy
*/
template <typename T = Counter, class Bin = NoBin>
class VectorAverageDeviation
: public Detail::VectorDistBase<T, Detail::AvgFancy, Bin>
{
private:
+ /** The base implementation */
typedef Detail::VectorDistBase<T, Detail::AvgFancy, Bin> Base;
+ /** The parameter type. */
typedef typename Detail::DistStor<T>::Params Params;
public:
-/** This must be called to initialize some data members and allocate
- * approprate storage space for the stat.
- *@param size The size of the Vector
- * @return The VectorAverageDeviation itself.
- */
+ /**
+ * Initialize storage for this distribution.
+ * @param size The size of the vector.
+ * @return A reference to this distribution.
+ */
VectorAverageDeviation &init(int size) {
bin.init(size, params);
setInit();
}
};
-/** @ingroup VStats
- *This is a formula type. When defining it, you can just say:
- *Formula foo = manchu + 3 / bar;
- *The calculations for Formulas are all done at the end of the simulation, this
- *really is just a definition of how to calculate at the end.
+/**
+ * A formula for statistics that is calculated when printed. A formula is
+ * stored as a tree of Nodes that represent the equation to calculate.
+ * @sa Stat, ScalarStat, VectorStat, Node, Detail::Temp
*/
class Formula : public Detail::VectorStat
{
private:
/** The root of the tree which represents the Formula */
Detail::NodePtr root;
- friend class Detail::Temp;
+ friend class Statistics::Detail::Temp;
public:
+ /**
+ * Create and initialize thie formula, and register it with the database.
+ */
Formula() : VectorStat(true) { setInit(); }
+ /**
+ * Create a formula with the given root node, register it with the
+ * database.
+ * @param r The root of the expression tree.
+ */
Formula(Detail::Temp r) : VectorStat(true) {
root = r;
assert(size());
}
+ /**
+ * Set an unitialized Formula to the given root.
+ * @param r The root of the expression tree.
+ * @return a reference to this formula.
+ */
const Formula &operator=(Detail::Temp r) {
assert(!root && "Can't change formulas");
root = r;
return *this;
}
+ /**
+ * Add the given tree to the existing one.
+ * @param r The root of the expression tree.
+ * @return a reference to this formula.
+ */
const Formula &operator+=(Detail::Temp r) {
using namespace Detail;
if (root)
return *this;
}
+ /**
+ * Return the vector of values of this formula.
+ * @return The result vector.
+ */
const rvec_t &val() const { return root->val(); }
+ /**
+ * Return the total of the result vector.
+ * @return The total of the result vector.
+ */
result_t total() const { return root->total(); }
+ /**
+ * Return the number of elements in the tree.
+ */
size_t size() const {
if (!root)
return 0;
}
};
+/**
+ * @}
+ */
+
void check();
void dump(std::ostream &stream);
projects / gem5.git / commitdiff