diff options
Diffstat (limited to 'base/statistics.hh')
| -rw-r--r-- | base/statistics.hh | 1275 |
1 files changed, 480 insertions, 795 deletions
diff --git a/base/statistics.hh b/base/statistics.hh index 0dad31a5a..e7fc18d74 100644 --- a/base/statistics.hh +++ b/base/statistics.hh @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003 The Regents of The University of Michigan + * Copyright (c) 2003-2004 The Regents of The University of Michigan * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -42,8 +42,8 @@ * VectorStandardDeviation totals * Document Namespaces */ -#ifndef __STATISTICS_HH__ -#define __STATISTICS_HH__ +#ifndef __BASE_STATISTICS_HH__ +#define __BASE_STATISTICS_HH__ #include <algorithm> #include <cassert> @@ -58,66 +58,19 @@ #include "base/intmath.hh" #include "base/refcnt.hh" #include "base/str.hh" +#include "base/stats/bin.hh" +#include "base/stats/flags.hh" +#include "base/stats/visit.hh" +#include "base/stats/types.hh" #include "sim/host.hh" -#ifndef NAN -float __nan(); -/** Define Not a number. */ -#define NAN (__nan()) -/** Need to define __nan() */ -#define __M5_NAN -#endif - class Callback; -class Python; /** The current simulated cycle. */ extern Tick curTick; /* A namespace for all of the Statistics */ namespace Statistics { -/** All results are doubles. */ -typedef double result_t; -/** A vector to hold results. */ -typedef std::vector<result_t> rvec_t; - -/** - * Define the storage for format flags. - * @todo Can probably shrink this. - */ -typedef u_int32_t StatFlags; - -/** Nothing extra to print. */ -const StatFlags none = 0x00000000; -/** This Stat is Initialized */ -const StatFlags init = 0x00000001; -/** Print this stat. */ -const StatFlags print = 0x00000002; -/** Print the total. */ -const StatFlags total = 0x00000010; -/** Print the percent of the total that this entry represents. */ -const StatFlags pdf = 0x00000020; -/** Print the cumulative percentage of total upto this entry. */ -const StatFlags cdf = 0x00000040; -/** Print the distribution. */ -const StatFlags dist = 0x00000080; -/** Don't print if this is zero. */ -const StatFlags nozero = 0x00000100; -/** Don't print if this is NAN */ -const StatFlags nonan = 0x00000200; -/** Used for SS compatability. */ -const StatFlags __substat = 0x80000000; - -/** Mask of flags that can't be set directly */ -const StatFlags __reserved = init | print | __substat; - -enum DisplayMode -{ - mode_m5, - mode_simplescalar -}; - -extern DisplayMode DefaultMode; /* Contains the statistic implementation details */ ////////////////////////////////////////////////////////////////////// @@ -135,10 +88,13 @@ struct StatData StatFlags flags; /** The display precision. */ int precision; - - /** A pointer to a prerequisite Stat. */ const StatData *prereq; + /** + * A unique stat ID for each stat in the simulator. + * Can be used externally for lookups as well as for debugging. + */ + int id; StatData(); virtual ~StatData(); @@ -149,14 +105,6 @@ struct StatData virtual bool binned() const = 0; /** - * Print this stat to the given ostream. - * @param stream The stream to print to. - */ - virtual void display(std::ostream &stream, DisplayMode mode) const = 0; - virtual void python(Python &py) const = 0; - bool dodisplay() const { return !prereq || !prereq->zero(); } - - /** * Reset the corresponding stat to the default state. */ virtual void reset() = 0; @@ -176,6 +124,11 @@ struct StatData bool baseCheck() const; /** + * Visitor entry for outputing statistics data + */ + virtual void visit(Visit &visitor) = 0; + + /** * Checks if the first stat's name is alphabetically less than the second. * This function breaks names up at periods and considers each subname * separately. @@ -184,51 +137,46 @@ struct StatData * @return stat1's name is alphabetically before stat2's */ static bool less(StatData *stat1, StatData *stat2); - -#ifdef DEBUG - int number; -#endif }; -struct ScalarDataBase : public StatData +struct ScalarData : public StatData { - virtual result_t val() const = 0; - virtual result_t total() const = 0; - - virtual void display(std::ostream &stream, DisplayMode mode) const; - virtual void python(Python &py) const; + virtual Counter value() const = 0; + virtual Result result() const = 0; + virtual Result total() const = 0; }; -template <class T> -class ScalarData : public ScalarDataBase +template <class Stat> +class ScalarStatData : public ScalarData { protected: - T &s; + Stat &s; public: - ScalarData(T &stat) : s(stat) {} + ScalarStatData(Stat &stat) : s(stat) {} virtual bool binned() const { return s.binned(); } virtual bool check() const { return s.check(); } - virtual result_t val() const { return s.val(); } - virtual result_t total() const { return s.total(); } + virtual Counter value() const { return s.value(); } + virtual Result result() const { return s.result(); } + virtual Result total() const { return s.total(); } virtual void reset() { s.reset(); } virtual bool zero() const { return s.zero(); } + + virtual void visit(Visit &visitor) { visitor.visit(*this); } }; -struct VectorDataBase : public StatData +struct VectorData : public StatData { /** Names and descriptions of subfields. */ mutable std::vector<std::string> subnames; mutable std::vector<std::string> subdescs; - virtual void display(std::ostream &stream, DisplayMode mode) const; - virtual void python(Python &py) const; - virtual size_t size() const = 0; - virtual const rvec_t &val() const = 0; - virtual result_t total() const = 0; - virtual void update() + virtual const VCounter &value() const = 0; + virtual const VResult &result() const = 0; + virtual Result total() const = 0; + void update() { if (!subnames.empty()) { int s = size(); @@ -241,15 +189,16 @@ struct VectorDataBase : public StatData } }; -template <class T> -class VectorData : public VectorDataBase +template <class Stat> +class VectorStatData : public VectorData { protected: - T &s; - mutable rvec_t vec; + Stat &s; + mutable VCounter cvec; + mutable VResult rvec; public: - VectorData(T &stat) : s(stat) {} + VectorStatData(Stat &stat) : s(stat) {} virtual bool binned() const { return s.binned(); } virtual bool check() const { return s.check(); } @@ -257,66 +206,70 @@ class VectorData : public VectorDataBase virtual void reset() { s.reset(); } virtual size_t size() const { return s.size(); } - virtual const rvec_t &val() const + virtual VCounter &value() const { - s.val(vec); - return vec; + s.value(cvec); + return cvec; + } + virtual const VResult &result() const + { + s.result(rvec); + return rvec; } - virtual result_t total() const { return s.total(); } - virtual void update() + virtual Result total() const { return s.total(); } + virtual void visit(Visit &visitor) { - VectorDataBase::update(); + update(); s.update(this); + visitor.visit(*this); } }; struct DistDataData { - result_t min_val; - result_t max_val; - result_t underflow; - result_t overflow; - rvec_t vec; - result_t sum; - result_t squares; - result_t samples; - - int min; - int max; - int bucket_size; + Counter min_val; + Counter max_val; + Counter underflow; + Counter overflow; + VCounter cvec; + Counter sum; + Counter squares; + Counter samples; + + Counter min; + Counter max; + Counter bucket_size; int size; bool fancy; - - void python(Python &py, const std::string &name) const; }; -struct DistDataBase : public StatData +struct DistData : public StatData { /** Local storage for the entry values, used for printing. */ DistDataData data; - - virtual void display(std::ostream &stream, DisplayMode mode) const; - virtual void python(Python &py) const; - virtual void update() = 0; }; -template <class T> -class DistData : public DistDataBase +template <class Stat> +class DistStatData : public DistData { protected: - T &s; + Stat &s; public: - DistData(T &stat) : s(stat) {} + DistStatData(Stat &stat) : s(stat) {} virtual bool binned() const { return s.binned(); } virtual bool check() const { return s.check(); } virtual void reset() { s.reset(); } virtual bool zero() const { return s.zero(); } - virtual void update() { return s.update(this); } + virtual void visit(Visit &visitor) + { + s.update(this); + visitor.visit(*this); + } }; -struct VectorDistDataBase : public StatData +struct VectorDistData : public StatData { std::vector<DistDataData> data; @@ -325,12 +278,10 @@ struct VectorDistDataBase : public StatData mutable std::vector<std::string> subdescs; /** Local storage for the entry values, used for printing. */ - mutable rvec_t vec; + mutable VResult rvec; virtual size_t size() const = 0; - virtual void display(std::ostream &stream, DisplayMode mode) const; - virtual void python(Python &py) const; - virtual void update() + void update() { int s = size(); if (subnames.size() < s) @@ -341,29 +292,30 @@ struct VectorDistDataBase : public StatData } }; -template <class T> -class VectorDistData : public VectorDistDataBase +template <class Stat> +class VectorDistStatData : public VectorDistData { protected: - T &s; - typedef typename T::bin_t bin_t; + Stat &s; + typedef typename Stat::bin_t bin_t; public: - VectorDistData(T &stat) : s(stat) {} + VectorDistStatData(Stat &stat) : s(stat) {} virtual bool binned() const { return bin_t::binned; } virtual bool check() const { return s.check(); } virtual void reset() { s.reset(); } virtual size_t size() const { return s.size(); } virtual bool zero() const { return s.zero(); } - virtual void update() + virtual void visit(Visit &visitor) { - VectorDistDataBase::update(); - return s.update(this); + update(); + s.update(this); + visitor.visit(*this); } }; -struct Vector2dDataBase : public StatData +struct Vector2dData : public StatData { /** Names and descriptions of subfields. */ std::vector<std::string> subnames; @@ -371,37 +323,36 @@ struct Vector2dDataBase : public StatData std::vector<std::string> y_subnames; /** Local storage for the entry values, used for printing. */ - mutable rvec_t vec; + mutable VCounter cvec; mutable int x; mutable int y; - virtual void display(std::ostream &stream, DisplayMode mode) const; - virtual void python(Python &py) const; - virtual void update() + void update() { if (subnames.size() < x) subnames.resize(x); } }; -template <class T> -class Vector2dData : public Vector2dDataBase +template <class Stat> +class Vector2dStatData : public Vector2dData { protected: - T &s; - typedef typename T::bin_t bin_t; + Stat &s; + typedef typename Stat::bin_t bin_t; public: - Vector2dData(T &stat) : s(stat) {} + Vector2dStatData(Stat &stat) : s(stat) {} virtual bool binned() const { return bin_t::binned; } virtual bool check() const { return s.check(); } virtual void reset() { s.reset(); } virtual bool zero() const { return s.zero(); } - virtual void update() + virtual void visit(Visit &visitor) { - Vector2dDataBase::update(); + update(); s.update(this); + visitor.visit(*this); } }; @@ -502,8 +453,8 @@ class Wrap : public Child * @param prereq The prerequisite stat. * @return A reference to this stat. */ - template <class T> - Parent &prereq(const T &prereq) + template <class Stat> + Parent &prereq(const Stat &prereq) { statData()->prereq = prereq.statData(); return self(); @@ -571,9 +522,9 @@ class WrapVec2d : public WrapVec<Parent, Child, Data> Parent &ysubname(int index, const std::string subname) { Data<Child> *data = statData(); - assert(i < y); + assert(index < y); data->y_subnames.resize(y); - data->y_subnames[i] = subname.c_str(); + data->y_subnames[index] = subname.c_str(); return self(); } }; @@ -587,7 +538,6 @@ class WrapVec2d : public WrapVec<Parent, Child, Data> /** * Templatized storage and interface for a simple scalar stat. */ -template <typename T> struct StatStor { public: @@ -596,59 +546,54 @@ struct StatStor private: /** The statistic value. */ - T data; - static T &Null() - { - static T __T = T(); - return __T; - } + Counter data; public: /** * Builds this storage element and calls the base constructor of the * datatype. */ - StatStor(const Params &) : data(Null()) {} + StatStor(const Params &) : data(Counter()) {} /** * 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; } + void set(Counter 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; } + void inc(Counter 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; } + void dec(Counter 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 as its base type. + * @param p The params of this storage type. * @return The value of this stat. */ - result_t val(const Params &p) const { return (result_t)data; } + Counter value(const Params &p) const { return 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 as a result type. + * @param p The parameters of this storage type. * @return The value of this stat. */ - T value(const Params &p) const { return data; } + Result result(const Params &p) const { return (Result)data; } /** * Reset stat value to default */ - void reset() { data = Null(); } + void reset() { data = Counter(); } /** * @return true if zero value */ - bool zero() const { return data == Null(); } + bool zero() const { return data == Counter(); } }; /** @@ -659,7 +604,6 @@ struct StatStor * among other things. * @todo add lateny to the stat and fix binning. */ -template <typename T> struct AvgStor { public: @@ -670,12 +614,12 @@ struct AvgStor * The current count. We stash this here because the current * value is not a binned value. */ - T current; + Counter current; }; private: /** The total count for all cycles. */ - mutable result_t total; + mutable Result total; /** The cycle that current last changed. */ mutable Tick last; @@ -683,7 +627,7 @@ struct AvgStor /** * Build and initializes this stat storage. */ - AvgStor(Params &p) : total(0), last(0) { p.current = T(); } + AvgStor(Params &p) : total(0), last(0) { p.current = Counter(); } /** * Set the current count to the one provided, update the total and last @@ -691,7 +635,7 @@ struct AvgStor * @param val The new count. * @param p The parameters for this storage. */ - void set(T val, Params &p) { + void set(Counter val, Params &p) { total += p.current * (curTick - last); last = curTick; p.current = val; @@ -702,34 +646,35 @@ struct AvgStor * @param val The amount to increment. * @param p The parameters for this storage. */ - void inc(T val, Params &p) { set(p.current + val, p); } + void inc(Counter val, Params &p) { set(p.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, Params &p) { set(p.current - val, p); } + void dec(Counter val, Params &p) { set(p.current - val, p); } + + /** + * Return the current count. + * @param p The parameters for this storage. + * @return The current count. + */ + Counter value(const Params &p) const { return p.current; } /** * Return the current average. * @param p The parameters for this storage. * @return The current average. */ - result_t val(const Params &p) const { + Result result(const Params &p) const + { total += p.current * (curTick - last); last = curTick; - return (result_t)(total + p.current) / (result_t)(curTick + 1); + return (Result)(total + p.current) / (Result)(curTick + 1); } /** - * Return the current count. - * @param p The parameters for this storage. - * @return The current count. - */ - T value(const Params &p) const { return p.current; } - - /** * Reset stat value to default */ void reset() @@ -749,16 +694,14 @@ struct AvgStor * 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> +template <class Storage, class Bin> class ScalarBase : public DataAccess { public: - /** 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; + typedef typename Storage::Params params_t; /** Define the bin type. */ - typedef typename Bin::Bin<storage_t> bin_t; + typedef typename Bin::Bin<Storage> bin_t; protected: /** The bin of this stat. */ @@ -771,12 +714,12 @@ class ScalarBase : public DataAccess * Retrieve the storage from the bin. * @return The storage object for this stat. */ - storage_t *data() { return bin.data(params); } + Storage *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 + const Storage *data() const { bin_t *_bin = const_cast<bin_t *>(&bin); params_t *_params = const_cast<params_t *>(¶ms); @@ -798,7 +741,7 @@ class ScalarBase : public DataAccess * Return the current value of this stat as its base type. * @return The current value. */ - T value() const { return data()->value(params); } + Counter value() const { return data()->value(params); } public: /** @@ -869,11 +812,14 @@ class ScalarBase : public DataAccess */ void reset() { bin.reset(); } - result_t val() { return data()->val(params); } + Counter value() { return data()->value(params); } + + Result result() { return data()->result(params); } - result_t total() { return val(); } + Result total() { return result(); } + + bool zero() { return result() == 0.0; } - bool zero() { return val() == 0.0; } }; ////////////////////////////////////////////////////////////////////// @@ -881,23 +827,21 @@ class ScalarBase : public DataAccess // Vector Statistics // ////////////////////////////////////////////////////////////////////// -template <typename T, template <typename T> class Storage, class Bin> +template <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> +template <class Storage, class Bin> class VectorBase : public DataAccess { public: - /** 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; + typedef typename Storage::Params params_t; /** Define the bin type. */ - typedef typename Bin::VectorBin<storage_t> bin_t; + typedef typename Bin::VectorBin<Storage> bin_t; protected: /** The bin of this stat. */ @@ -911,14 +855,14 @@ class VectorBase : public DataAccess * @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); } + Storage *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 + const Storage *data(int index) const { bin_t *_bin = const_cast<bin_t *>(&bin); params_t *_params = const_cast<params_t *>(¶ms); @@ -933,15 +877,22 @@ class VectorBase : public DataAccess const VectorBase &operator=(const VectorBase &); public: + void value(VCounter &vec) const + { + vec.resize(size()); + for (int i = 0; i < size(); ++i) + vec[i] = data(i)->value(params); + } + /** * Copy the values to a local vector and return a reference to it. * @return A reference to a vector of the stat values. */ - void val(rvec_t &vec) const + void result(VResult &vec) const { vec.resize(size()); for (int i = 0; i < size(); ++i) - vec[i] = data(i)->val(params); + vec[i] = data(i)->result(params); } /** @@ -953,10 +904,10 @@ class VectorBase : public DataAccess * 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; + Result total() const { + Result total = 0.0; for (int i = 0; i < size(); ++i) - total += data(i)->val(params); + total += data(i)->result(params); return total; } @@ -980,14 +931,14 @@ class VectorBase : public DataAccess VectorBase() {} /** Friend this class with the associated scalar proxy. */ - friend class ScalarProxy<T, Storage, Bin>; + friend class ScalarProxy<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); + ScalarProxy<Storage, Bin> operator[](int index); void update(StatData *data) {} }; @@ -998,16 +949,14 @@ const StatData * getStatData(const void *stat); * 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> +template <class Storage, class Bin> class ScalarProxy { public: - /** 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; + typedef typename Storage::Params params_t; /** Define the bin type. */ - typedef typename Bin::VectorBin<storage_t> bin_t; + typedef typename Bin::VectorBin<Storage> bin_t; private: /** Pointer to the bin in the parent VectorBase. */ @@ -1024,12 +973,12 @@ class ScalarProxy * Retrieve the storage from the bin. * @return The storage from the bin for this stat. */ - storage_t *data() { return bin->data(index, *params); } + Storage *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 + const Storage *data() const { bin_t *_bin = const_cast<bin_t *>(bin); params_t *_params = const_cast<params_t *>(params); @@ -1038,15 +987,16 @@ class ScalarProxy public: /** - * Return the current value of this statas a result type. + * Return the current value of this stat as its base type. * @return The current value. */ - result_t val() const { return data()->val(*params); } + Counter value() const { return data()->value(*params); } + /** - * Return the current value of this stat as its base type. + * Return the current value of this statas a result type. * @return The current value. */ - T value() const { return data()->value(*params); } + Result result() const { return data()->result(*params); } public: /** @@ -1144,24 +1094,23 @@ class ScalarProxy } }; -template <typename T, template <typename T> class Storage, class Bin> -inline ScalarProxy<T, Storage, Bin> -VectorBase<T, Storage, Bin>::operator[](int index) +template <class Storage, class Bin> +inline ScalarProxy<Storage, Bin> +VectorBase<Storage, Bin>::operator[](int index) { assert (index >= 0 && index < size()); - return ScalarProxy<T, Storage, Bin>(bin, params, index, this); + return ScalarProxy<Storage, Bin>(bin, params, index, this); } -template <typename T, template <typename T> class Storage, class Bin> +template <class Storage, class Bin> class VectorProxy; -template <typename T, template <typename T> class Storage, class Bin> +template <class Storage, class Bin> class Vector2dBase : public DataAccess { public: - typedef Storage<T> storage_t; - typedef typename storage_t::Params params_t; - typedef typename Bin::VectorBin<storage_t> bin_t; + typedef typename Storage::Params params_t; + typedef typename Bin::VectorBin<Storage> bin_t; protected: size_t x; @@ -1170,8 +1119,8 @@ class Vector2dBase : public DataAccess params_t params; protected: - storage_t *data(int index) { return bin.data(index, params); } - const storage_t *data(int index) const + Storage *data(int index) { return bin.data(index, params); } + const Storage *data(int index) const { bin_t *_bin = const_cast<bin_t *>(&bin); params_t *_params = const_cast<params_t *>(¶ms); @@ -1186,18 +1135,18 @@ class Vector2dBase : public DataAccess public: Vector2dBase() {} - void update(Vector2dDataBase *data) + void update(Vector2dData *data) { int size = this->size(); - data->vec.resize(size); + data->cvec.resize(size); for (int i = 0; i < size; ++i) - data->vec[i] = this->data(i)->val(params); + data->cvec[i] = this->data(i)->value(params); } std::string ysubname(int i) const { return (*y_subnames)[i]; } - friend class VectorProxy<T, Storage, Bin>; - VectorProxy<T, Storage, Bin> operator[](int index); + friend class VectorProxy<Storage, Bin>; + VectorProxy<Storage, Bin> operator[](int index); size_t size() const { return bin.size(); } bool zero() const { return data(0)->value(params) == 0.0; } @@ -1210,13 +1159,12 @@ class Vector2dBase : public DataAccess bool check() { return bin.initialized(); } }; -template <typename T, template <typename T> class Storage, class Bin> +template <class Storage, class Bin> class VectorProxy { public: - typedef Storage<T> storage_t; - typedef typename storage_t::Params params_t; - typedef typename Bin::VectorBin<storage_t> bin_t; + typedef typename Storage::Params params_t; + typedef typename Bin::VectorBin<Storage> bin_t; private: bin_t *bin; @@ -1226,36 +1174,36 @@ class VectorProxy void *stat; private: - mutable rvec_t *vec; + mutable VResult *vec; - storage_t *data(int index) { + Storage *data(int index) { assert(index < len); return bin->data(offset + index, *params); } - const storage_t *data(int index) const { + const Storage *data(int index) const { bin_t *_bin = const_cast<bin_t *>(bin); params_t *_params = const_cast<params_t *>(params); return _bin->data(offset + index, *_params); } public: - const rvec_t &val() const { + const VResult &result() const { if (vec) vec->resize(size()); else - vec = new rvec_t(size()); + vec = new VResult(size()); for (int i = 0; i < size(); ++i) - (*vec)[i] = data(i)->val(*params); + (*vec)[i] = data(i)->result(*params); return *vec; } - result_t total() const { - result_t total = 0.0; + Result total() const { + Result total = 0.0; for (int i = 0; i < size(); ++i) - total += data(i)->val(*params); + total += data(i)->result(*params); return total; } @@ -1290,11 +1238,10 @@ class VectorProxy return *this; } - ScalarProxy<T, Storage, Bin> operator[](int index) + ScalarProxy<Storage, Bin> operator[](int index) { assert (index >= 0 && index < size()); - return ScalarProxy<T, Storage, Bin>(*bin, *params, offset + index, - stat); + return ScalarProxy<Storage, Bin>(*bin, *params, offset + index, stat); } size_t size() const { return len; } @@ -1311,13 +1258,13 @@ class VectorProxy void reset() { } }; -template <typename T, template <typename T> class Storage, class Bin> -inline VectorProxy<T, Storage, Bin> -Vector2dBase<T, Storage, Bin>::operator[](int index) +template <class Storage, class Bin> +inline VectorProxy<Storage, Bin> +Vector2dBase<Storage, Bin>::operator[](int index) { int offset = index * y; assert (index >= 0 && offset < size()); - return VectorProxy<T, Storage, Bin>(bin, params, offset, y, this); + return VectorProxy<Storage, Bin>(bin, params, offset, y, this); } ////////////////////////////////////////////////////////////////////// @@ -1329,7 +1276,6 @@ Vector2dBase<T, Storage, Bin>::operator[](int index) /** * Templatized storage and interface for a distrbution stat. */ -template <typename T> struct DistStor { public: @@ -1337,11 +1283,11 @@ struct DistStor struct Params { /** The minimum value to track. */ - int min; + Counter min; /** The maximum value to track. */ - int max; + Counter max; /** The number of entries in each bucket. */ - int bucket_size; + Counter bucket_size; /** The number of buckets. Equal to (max-min)/bucket_size. */ int size; }; @@ -1349,21 +1295,21 @@ struct DistStor private: /** The smallest value sampled. */ - T min_val; + Counter min_val; /** The largest value sampled. */ - T max_val; + Counter max_val; /** The number of values sampled less than min. */ - T underflow; + Counter underflow; /** The number of values sampled more than max. */ - T overflow; + Counter overflow; /** The current sum. */ - T sum; + Counter sum; /** The sum of squares. */ - T squares; + Counter squares; /** The number of samples. */ - int samples; + Counter samples; /** Counter for each bucket. */ - std::vector<T> vec; + VCounter cvec; public: /** @@ -1371,8 +1317,9 @@ struct DistStor * @param params The parameters. */ DistStor(const Params ¶ms) - : min_val(INT_MAX), max_val(INT_MIN), underflow(0), overflow(0), - sum(T()), squares(T()), samples(0), vec(params.size) + : min_val(INT_MAX), max_val(INT_MIN), underflow(Counter()), + overflow(Counter()), sum(Counter()), squares(Counter()), + samples(Counter()), cvec(params.size) { reset(); } @@ -1383,16 +1330,16 @@ struct DistStor * @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) + void sample(Counter val, int number, const Params ¶ms) { if (val < params.min) underflow += number; else if (val > params.max) overflow += number; else { - int index = (val - params.min) / params.bucket_size; + int index = (int)floor((val - params.min) / params.bucket_size); assert(index < size(params)); - vec[index] += number; + cvec[index] += number; } if (val < min_val) @@ -1401,7 +1348,7 @@ struct DistStor if (val > max_val) max_val = val; - T sample = val * number; + Counter sample = val * number; sum += sample; squares += sample * sample; samples += number; @@ -1412,7 +1359,7 @@ struct DistStor * @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(); } + size_t size(const Params &) const { return cvec.size(); } /** * Returns true if any calls to sample have been made. @@ -1421,7 +1368,7 @@ struct DistStor */ bool zero(const Params ¶ms) const { - return samples == 0; + return samples == Counter(); } void update(DistDataData *data, const Params ¶ms) @@ -1435,9 +1382,9 @@ struct DistStor data->max_val = (max_val == INT_MIN) ? 0 : max_val; data->underflow = underflow; data->overflow = overflow; - data->vec.resize(params.size); + data->cvec.resize(params.size); for (int i = 0; i < params.size; ++i) - data->vec[i] = vec[i]; + data->cvec[i] = cvec[i]; data->sum = sum; data->squares = squares; @@ -1454,13 +1401,13 @@ struct DistStor underflow = 0; overflow = 0; - int size = vec.size(); + int size = cvec.size(); for (int i = 0; i < size; ++i) - vec[i] = T(); + cvec[i] = Counter(); - sum = T(); - squares = T(); - samples = T(); + sum = Counter(); + squares = Counter(); + samples = Counter(); } }; @@ -1468,7 +1415,6 @@ struct DistStor * Templatized storage and interface for a distribution that calculates mean * and variance. */ -template <typename T> struct FancyStor { public: @@ -1480,17 +1426,19 @@ struct FancyStor private: /** The current sum. */ - T sum; + Counter sum; /** The sum of squares. */ - T squares; + Counter squares; /** The number of samples. */ - int samples; + Counter samples; public: /** * Create and initialize this storage. */ - FancyStor(const Params &) : sum(T()), squares(T()), samples(0) {} + FancyStor(const Params &) + : sum(Counter()), squares(Counter()), samples(Counter()) + { } /** * Add a value the given number of times to this running average. @@ -1500,9 +1448,9 @@ struct FancyStor * @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) + void sample(Counter val, int number, const Params &p) { - T value = val * number; + Counter value = val * number; sum += value; squares += value * value; samples += number; @@ -1525,16 +1473,16 @@ struct FancyStor * Return true if no samples have been added. * @return True if no samples have been added. */ - bool zero(const Params &) const { return samples == 0; } + bool zero(const Params &) const { return samples == Counter(); } /** * Reset stat value to default */ void reset() { - sum = T(); - squares = T(); - samples = 0; + sum = Counter(); + squares = Counter(); + samples = Counter(); } }; @@ -1542,7 +1490,6 @@ struct FancyStor * Templatized storage for distribution that calculates per cycle mean and * variance. */ -template <typename T> struct AvgFancy { public: @@ -1552,15 +1499,15 @@ struct AvgFancy private: /** Current total. */ - T sum; + Counter sum; /** Current sum of squares. */ - T squares; + Counter squares; public: /** * Create and initialize this storage. */ - AvgFancy(const Params &) : sum(T()), squares(T()) {} + AvgFancy(const Params &) : sum(Counter()), squares(Counter()) {} /** * Add a value to the distribution for the given number of times. @@ -1569,9 +1516,9 @@ struct AvgFancy * @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) + void sample(Counter val, int number, const Params &p) { - T value = val * number; + Counter value = val * number; sum += value; squares += value * value; } @@ -1592,14 +1539,14 @@ struct AvgFancy * Return true if no samples have been added. * @return True if the sum is zero. */ - bool zero(const Params ¶ms) const { return sum == 0; } + bool zero(const Params ¶ms) const { return sum == Counter(); } /** * Reset stat value to default */ void reset() { - sum = T(); - squares = T(); + sum = Counter(); + squares = Counter(); } }; @@ -1607,16 +1554,14 @@ struct AvgFancy * 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> +template <class Storage, class Bin> class DistBase : public DataAccess { public: - /** 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; + typedef typename Storage::Params params_t; /** Define the bin type. */ - typedef typename Bin::Bin<storage_t> bin_t; + typedef typename Bin::Bin<Storage> bin_t; protected: /** The bin of this stat. */ @@ -1629,12 +1574,12 @@ class DistBase : public DataAccess * Retrieve the storage from the bin. * @return The storage object for this stat. */ - storage_t *data() { return bin.data(params); } + Storage *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 + const Storage *data() const { bin_t *_bin = const_cast<bin_t *>(&bin); params_t *_params = const_cast<params_t *>(¶ms); @@ -1671,9 +1616,9 @@ class DistBase : public DataAccess */ bool zero() const { return data()->zero(params); } - void update(DistDataBase *base) + void update(DistData *base) { - base->data.fancy = storage_t::fancy; + base->data.fancy = Storage::fancy; data()->update(&(base->data), params); } /** @@ -1691,24 +1636,23 @@ class DistBase : public DataAccess bool check() { return bin.initialized(); } }; -template <typename T, template <typename T> class Storage, class Bin> +template <class Storage, class Bin> class DistProxy; -template <typename T, template <typename T> class Storage, class Bin> +template <class Storage, class Bin> class VectorDistBase : public DataAccess { public: - typedef Storage<T> storage_t; - typedef typename storage_t::Params params_t; - typedef typename Bin::VectorBin<storage_t> bin_t; + typedef typename Storage::Params params_t; + typedef typename Bin::VectorBin<Storage> bin_t; protected: bin_t bin; params_t params; protected: - storage_t *data(int index) { return bin.data(index, params); } - const storage_t *data(int index) const + Storage *data(int index) { return bin.data(index, params); } + const Storage *data(int index) const { bin_t *_bin = const_cast<bin_t *>(&bin); params_t *_params = const_cast<params_t *>(¶ms); @@ -1723,9 +1667,9 @@ class VectorDistBase : public DataAccess public: VectorDistBase() {} - friend class DistProxy<T, Storage, Bin>; - DistProxy<T, Storage, Bin> operator[](int index); - const DistProxy<T, Storage, Bin> operator[](int index) const; + friend class DistProxy<Storage, Bin>; + DistProxy<Storage, Bin> operator[](int index); + const DistProxy<Storage, Bin> operator[](int index) const; size_t size() const { return bin.size(); } bool zero() const { return false; } @@ -1740,25 +1684,24 @@ class VectorDistBase : public DataAccess void reset() { bin.reset(); } bool check() { return bin.initialized(); } - void update(VectorDistDataBase *base) + void update(VectorDistData *base) { int size = this->size(); base->data.resize(size); for (int i = 0; i < size; ++i) { - base->data[i].fancy = storage_t::fancy; + base->data[i].fancy = Storage::fancy; data(i)->update(&(base->data[i]), params); } } }; -template <typename T, template <typename T> class Storage, class Bin> +template <class Storage, class Bin> class DistProxy { public: - typedef Storage<T> storage_t; - typedef typename storage_t::Params params_t; - typedef typename Bin::Bin<storage_t> bin_t; - typedef VectorDistBase<T, Storage, Bin> base_t; + typedef typename Storage::Params params_t; + typedef typename Bin::Bin<Storage> bin_t; + typedef VectorDistBase<Storage, Bin> base_t; private: union { @@ -1768,11 +1711,11 @@ class DistProxy int index; protected: - storage_t *data() { return stat->data(index); } - const storage_t *data() const { return cstat->data(index); } + Storage *data() { return stat->data(index); } + const Storage *data() const { return cstat->data(index); } public: - DistProxy(const VectorDistBase<T, Storage, Bin> &s, int i) + DistProxy(const VectorDistBase<Storage, Bin> &s, int i) : cstat(&s), index(i) {} DistProxy(const DistProxy &sp) : cstat(sp.cstat), index(sp.index) {} @@ -1797,30 +1740,30 @@ class DistProxy void reset() { } }; -template <typename T, template <typename T> class Storage, class Bin> -inline DistProxy<T, Storage, Bin> -VectorDistBase<T, Storage, Bin>::operator[](int index) +template <class Storage, class Bin> +inline DistProxy<Storage, Bin> +VectorDistBase<Storage, Bin>::operator[](int index) { assert (index >= 0 && index < size()); - return DistProxy<T, Storage, Bin>(*this, index); + return DistProxy<Storage, Bin>(*this, index); } -template <typename T, template <typename T> class Storage, class Bin> -inline const DistProxy<T, Storage, Bin> -VectorDistBase<T, Storage, Bin>::operator[](int index) const +template <class Storage, class Bin> +inline const DistProxy<Storage, Bin> +VectorDistBase<Storage, Bin>::operator[](int index) const { assert (index >= 0 && index < size()); - return DistProxy<T, Storage, Bin>(*this, index); + return DistProxy<Storage, Bin>(*this, index); } #if 0 -template <typename T, template <typename T> class Storage, class Bin> -result_t -VectorDistBase<T, Storage, Bin>::total(int index) const +template <class Storage, class Bin> +Result +VectorDistBase<Storage, Bin>::total(int index) const { int total = 0; for (int i=0; i < x_size(); ++i) { - total += data(i)->val(*params); + total += data(i)->result(*params); } } #endif @@ -1847,12 +1790,12 @@ class Node : public RefCounted * Return the result vector of this subtree. * @return The result vector of this subtree. */ - virtual const rvec_t &val() const = 0; + virtual const VResult &result() const = 0; /** * Return the total of the result vector. * @return The total of the result vector. */ - virtual result_t total() const = 0; + virtual Result total() const = 0; /** * Return true if stat is binned. *@return True is stat is binned. @@ -1871,17 +1814,17 @@ typedef RefCountingPtr<Node> NodePtr; class ScalarStatNode : public Node { private: - const ScalarDataBase *data; - mutable rvec_t result; + const ScalarData *data; + mutable VResult vresult; public: - ScalarStatNode(const ScalarDataBase *d) : data(d), result(1) {} - virtual const rvec_t &val() const + ScalarStatNode(const ScalarData *d) : data(d), vresult(1) {} + virtual const VResult &result() const { - result[0] = data->val(); - return result; + vresult[0] = data->result(); + return vresult; } - virtual result_t total() const { return data->val(); }; + virtual Result total() const { return data->result(); }; virtual size_t size() const { return 1; } /** @@ -1896,22 +1839,22 @@ class ScalarStatNode : public Node virtual std::string str() const { return data->name; } }; -template <typename T, template <typename T> class Storage, class Bin> +template <class Storage, class Bin> class ScalarProxyNode : public Node { private: - const ScalarProxy<T, Storage, Bin> proxy; - mutable rvec_t result; + const ScalarProxy<Storage, Bin> proxy; + mutable VResult vresult; public: - ScalarProxyNode(const ScalarProxy<T, Storage, Bin> &p) - : proxy(p), result(1) { } - virtual const rvec_t &val() const + ScalarProxyNode(const ScalarProxy<Storage, Bin> &p) + : proxy(p), vresult(1) { } + virtual const VResult &result() const { - result[0] = proxy.val(); - return result; + vresult[0] = proxy.result(); + return vresult; } - virtual result_t total() const { return proxy.val(); }; + virtual Result total() const { return proxy.result(); }; virtual size_t size() const { return 1; } /** @@ -1929,12 +1872,12 @@ class ScalarProxyNode : public Node class VectorStatNode : public Node { private: - const VectorDataBase *data; + const VectorData *data; public: - VectorStatNode(const VectorDataBase *d) : data(d) { } - virtual const rvec_t &val() const { return data->val(); } - virtual result_t total() const { return data->total(); }; + VectorStatNode(const VectorData *d) : data(d) { } + virtual const VResult &result() const { return data->result(); } + virtual Result total() const { return data->total(); }; virtual size_t size() const { return data->size(); } /** @@ -1946,41 +1889,42 @@ class VectorStatNode : public Node virtual std::string str() const { return data->name; } }; -template <typename T> +template <class T> class ConstNode : public Node { private: - rvec_t data; + VResult vresult; public: - ConstNode(T s) : data(1, (result_t)s) {} - const rvec_t &val() const { return data; } - virtual result_t total() const { return data[0]; }; - + ConstNode(T s) : vresult(1, (Result)s) {} + const VResult &result() const { return vresult; } + virtual Result total() const { return vresult[0]; }; virtual size_t size() const { return 1; } + /** * Return true if stat is binned. *@return False since constants aren't binned. */ virtual bool binned() const { return false; } - virtual std::string str() const { return to_string(data[0]); } + virtual std::string str() const { return to_string(vresult[0]); } }; -template <typename T> +template <class T> class FunctorNode : public Node { private: T &functor; - mutable rvec_t result; + mutable VResult vresult; public: - FunctorNode(T &f) : functor(f) { result.resize(1); } - const rvec_t &val() const { - result[0] = (result_t)functor(); - return result; + FunctorNode(T &f) : functor(f) { vresult.resize(1); } + const VResult &result() const + { + vresult[0] = (Result)functor(); + return vresult; } - virtual result_t total() const { return (result_t)functor(); }; + virtual Result total() const { return (Result)functor(); }; virtual size_t size() const { return 1; } /** @@ -1991,20 +1935,21 @@ class FunctorNode : public Node virtual std::string str() const { return to_string(functor()); } }; -template <typename T> +template <class T> class ScalarNode : public Node { private: T &scalar; - mutable rvec_t result; + mutable VResult vresult; public: - ScalarNode(T &s) : scalar(s) { result.resize(1); } - const rvec_t &val() const { - result[0] = (result_t)scalar; - return result; + ScalarNode(T &s) : scalar(s) { vresult.resize(1); } + const VResult &result() const + { + vresult[0] = (Result)scalar; + return vresult; } - virtual result_t total() const { return (result_t)scalar; }; + virtual Result total() const { return (Result)scalar; }; virtual size_t size() const { return 1; } /** @@ -2019,37 +1964,37 @@ template <class Op> struct OpString; template<> -struct OpString<std::plus<result_t> > +struct OpString<std::plus<Result> > { static std::string str() { return "+"; } }; template<> -struct OpString<std::minus<result_t> > +struct OpString<std::minus<Result> > { static std::string str() { return "-"; } }; template<> -struct OpString<std::multiplies<result_t> > +struct OpString<std::multiplies<Result> > { static std::string str() { return "*"; } }; template<> -struct OpString<std::divides<result_t> > +struct OpString<std::divides<Result> > { static std::string str() { return "/"; } }; template<> -struct OpString<std::modulus<result_t> > +struct OpString<std::modulus<Result> > { static std::string str() { return "%"; } }; template<> -struct OpString<std::negate<result_t> > +struct OpString<std::negate<Result> > { static std::string str() { return "-"; } }; @@ -2059,26 +2004,27 @@ class UnaryNode : public Node { public: NodePtr l; - mutable rvec_t result; + mutable VResult vresult; public: UnaryNode(NodePtr &p) : l(p) {} - const rvec_t &val() const { - const rvec_t &lvec = l->val(); + const VResult &result() const + { + const VResult &lvec = l->result(); int size = lvec.size(); assert(size > 0); - result.resize(size); + vresult.resize(size); Op op; for (int i = 0; i < size; ++i) - result[i] = op(lvec[i]); + vresult[i] = op(lvec[i]); - return result; + return vresult; } - result_t total() const { + Result total() const { Op op; return op(l->total()); } @@ -2102,42 +2048,43 @@ class BinaryNode : public Node public: NodePtr l; NodePtr r; - mutable rvec_t result; + mutable VResult vresult; public: BinaryNode(NodePtr &a, NodePtr &b) : l(a), r(b) {} - const rvec_t &val() const { + const VResult &result() const + { Op op; - const rvec_t &lvec = l->val(); - const rvec_t &rvec = r->val(); + const VResult &lvec = l->result(); + const VResult &rvec = r->result(); assert(lvec.size() > 0 && rvec.size() > 0); if (lvec.size() == 1 && rvec.size() == 1) { - result.resize(1); - result[0] = op(lvec[0], rvec[0]); + vresult.resize(1); + vresult[0] = op(lvec[0], rvec[0]); } else if (lvec.size() == 1) { int size = rvec.size(); - result.resize(size); + vresult.resize(size); for (int i = 0; i < size; ++i) - result[i] = op(lvec[0], rvec[i]); + vresult[i] = op(lvec[0], rvec[i]); } else if (rvec.size() == 1) { int size = lvec.size(); - result.resize(size); + vresult.resize(size); for (int i = 0; i < size; ++i) - result[i] = op(lvec[i], rvec[0]); + vresult[i] = op(lvec[i], rvec[0]); } else if (rvec.size() == lvec.size()) { int size = rvec.size(); - result.resize(size); + vresult.resize(size); for (int i = 0; i < size; ++i) - result[i] = op(lvec[i], rvec[i]); + vresult[i] = op(lvec[i], rvec[i]); } - return result; + return vresult; } - result_t total() const { + Result total() const { Op op; return op(l->total(), r->total()); } @@ -2171,37 +2118,39 @@ class SumNode : public Node { public: NodePtr l; - mutable rvec_t result; + mutable VResult vresult; public: - SumNode(NodePtr &p) : l(p), result(1) {} + SumNode(NodePtr &p) : l(p), vresult(1) {} - const rvec_t &val() const { - const rvec_t &lvec = l->val(); + const VResult &result() const + { + const VResult &lvec = l->result(); int size = lvec.size(); assert(size > 0); - result[0] = 0.0; + vresult[0] = 0.0; Op op; for (int i = 0; i < size; ++i) - result[0] = op(result[0], lvec[i]); + vresult[0] = op(vresult[0], lvec[i]); - return result; + return vresult; } - result_t total() const { - const rvec_t &lvec = l->val(); + Result total() const + { + const VResult &lvec = l->result(); int size = lvec.size(); assert(size > 0); - result_t result = 0.0; + Result vresult = 0.0; Op op; for (int i = 0; i < size; ++i) - result = op(result, lvec[i]); + vresult = op(vresult, lvec[i]); - return result; + return vresult; } virtual size_t size() const { return 1; } @@ -2217,268 +2166,6 @@ class SumNode : public Node } }; -////////////////////////////////////////////////////////////////////// -// -// Binning Interface -// -////////////////////////////////////////////////////////////////////// -struct MainBin -{ - class BinBase; - friend class MainBin::BinBase; - - private: - std::string _name; - char *mem; - - protected: - off_t memsize; - off_t size() const { return memsize; } - char *memory(off_t off); - - public: - static MainBin *&curBin() - { - static MainBin *current = NULL; - return current; - } - - static void setCurBin(MainBin *bin) { curBin() = bin; } - static MainBin *current() { assert(curBin()); return curBin(); } - - static off_t &offset() - { - static off_t offset = 0; - return offset; - } - - static off_t new_offset(size_t size) - { - size_t mask = sizeof(u_int64_t) - 1; - off_t off = offset(); - - // That one is for the last trailing flags byte. - offset() += (size + 1 + mask) & ~mask; - return off; - } - - public: - MainBin(const std::string &name); - ~MainBin(); - - const std::string & - name() const - { - return _name; - } - - void - activate() - { - setCurBin(this); - } - - class BinBase - { - private: - int offset; - - public: - BinBase() : offset(-1) {} - void allocate(size_t size) - { - offset = new_offset(size); - } - char *access() - { - assert(offset != -1); - return current()->memory(offset); - } - }; - - template <class Storage> - class Bin : public BinBase - { - public: - typedef typename Storage::Params Params; - - public: - enum { binned = true }; - Bin() { allocate(sizeof(Storage)); } - bool initialized() const { return true; } - void init(Params ¶ms) { } - - int size() const { return 1; } - - Storage * - data(Params ¶ms) - { - assert(initialized()); - char *ptr = access(); - char *flags = ptr + sizeof(Storage); - if (!(*flags & 0x1)) { - *flags |= 0x1; - new (ptr) Storage(params); - } - 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> - class VectorBin : public BinBase - { - public: - typedef typename Storage::Params Params; - - private: - int _size; - - public: - enum { binned = true }; - VectorBin() : _size(0) {} - - bool initialized() const { return _size > 0; } - void init(int s, Params ¶ms) - { - assert(!initialized()); - assert(s > 0); - _size = s; - allocate(_size * sizeof(Storage)); - } - - int size() const { return _size; } - - Storage *data(int index, Params ¶ms) - { - assert(initialized()); - assert(index >= 0 && index < size()); - char *ptr = access(); - char *flags = ptr + size() * sizeof(Storage); - if (!(*flags & 0x1)) { - *flags |= 0x1; - for (int i = 0; i < size(); ++i) - new (ptr + i * sizeof(Storage)) Storage(params); - } - 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(); - } - } - }; -}; - -struct NoBin -{ - template <class Storage> - struct Bin - { - 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(Params ¶ms) - { - new (ptr) Storage(params); - } - int size() const{ return 1; } - Storage *data(Params ¶ms) - { - assert(initialized()); - return reinterpret_cast<Storage *>(ptr); - } - void reset() - { - Storage *s = reinterpret_cast<Storage *>(ptr); - s->reset(); - } - }; - - template <class Storage> - struct VectorBin - { - public: - typedef typename Storage::Params Params; - enum { binned = false }; - - private: - char *ptr; - int _size; - - public: - VectorBin() : ptr(NULL) { } - ~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, Params ¶ms) - { - assert(s > 0 && "size must be positive!"); - assert(!initialized()); - _size = s; - ptr = new char[_size * sizeof(Storage)]; - for (int i = 0; i < _size; ++i) - new (ptr + i * sizeof(Storage)) Storage(params); - } - - int size() const { return _size; } - - Storage *data(int index, Params ¶ms) - { - assert(initialized()); - 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(); - } - } - }; -}; ////////////////////////////////////////////////////////////////////// // @@ -2508,15 +2195,15 @@ typedef NoBin DefaultBin; * This is a simple scalar statistic, like a counter. * @sa Stat, ScalarBase, StatStor */ -template <typename T = Counter, class Bin = DefaultBin> +template <class Bin = DefaultBin> class Scalar - : public Wrap<Scalar<T, Bin>, - ScalarBase<T, StatStor, Bin>, - ScalarData> + : public Wrap<Scalar<Bin>, + ScalarBase<StatStor, Bin>, + ScalarStatData> { public: /** The base implementation. */ - typedef ScalarBase<T, StatStor, Bin> Base; + typedef ScalarBase<StatStor, Bin> Base; Scalar() { @@ -2536,15 +2223,15 @@ class Scalar * A stat that calculates the per cycle average of a value. * @sa Stat, ScalarBase, AvgStor */ -template <typename T = Counter, class Bin = DefaultBin> +template <class Bin = DefaultBin> class Average - : public Wrap<Average<T, Bin>, - ScalarBase<T, AvgStor, Bin>, - ScalarData> + : public Wrap<Average<Bin>, + ScalarBase<AvgStor, Bin>, + ScalarStatData> { public: /** The base implementation. */ - typedef ScalarBase<T, AvgStor, Bin> Base; + typedef ScalarBase<AvgStor, Bin> Base; Average() { @@ -2564,15 +2251,15 @@ class Average * A vector of scalar stats. * @sa Stat, VectorBase, StatStor */ -template <typename T = Counter, class Bin = DefaultBin> +template <class Bin = DefaultBin> class Vector - : public WrapVec<Vector<T, Bin>, - VectorBase<T, StatStor, Bin>, - VectorData> + : public WrapVec<Vector<Bin>, + VectorBase<StatStor, Bin>, + VectorStatData> { public: /** The base implementation. */ - typedef ScalarBase<T, StatStor, Bin> Base; + typedef ScalarBase<StatStor, Bin> Base; /** * Set this vector to have the given size. @@ -2591,11 +2278,11 @@ class Vector * A vector of Average stats. * @sa Stat, VectorBase, AvgStor */ -template <typename T = Counter, class Bin = DefaultBin> +template <class Bin = DefaultBin> class AverageVector - : public WrapVec<AverageVector<T, Bin>, - VectorBase<T, AvgStor, Bin>, - VectorData> + : public WrapVec<AverageVector<Bin>, + VectorBase<AvgStor, Bin>, + VectorStatData> { public: /** @@ -2615,11 +2302,11 @@ class AverageVector * A 2-Dimensional vecto of scalar stats. * @sa Stat, Vector2dBase, StatStor */ -template <typename T = Counter, class Bin = DefaultBin> +template <class Bin = DefaultBin> class Vector2d - : public WrapVec2d<Vector2d<T, Bin>, - Vector2dBase<T, StatStor, Bin>, - Vector2dData> + : public WrapVec2d<Vector2d<Bin>, + Vector2dBase<StatStor, Bin>, + Vector2dStatData> { public: Vector2d &init(size_t _x, size_t _y) { @@ -2636,17 +2323,17 @@ class Vector2d * A simple distribution stat. * @sa Stat, DistBase, DistStor */ -template <typename T = Counter, class Bin = DefaultBin> +template <class Bin = DefaultBin> class Distribution - : public Wrap<Distribution<T, Bin>, - DistBase<T, DistStor, Bin>, - DistData> + : public Wrap<Distribution<Bin>, + DistBase<DistStor, Bin>, + DistStatData> { public: /** Base implementation. */ - typedef DistBase<T, DistStor, Bin> Base; + typedef DistBase<DistStor, Bin> Base; /** The Parameter type. */ - typedef typename DistStor<T>::Params Params; + typedef typename DistStor::Params Params; public: /** @@ -2656,11 +2343,11 @@ class Distribution * @param bkt The number of values in each bucket. * @return A reference to this distribution. */ - Distribution &init(T min, T max, int bkt) { + Distribution &init(Counter min, Counter max, Counter bkt) { params.min = min; params.max = max; params.bucket_size = bkt; - params.size = (max - min) / bkt + 1; + params.size = (int)rint((max - min) / bkt + 1.0); bin.init(params); setInit(); @@ -2672,17 +2359,17 @@ class Distribution * Calculates the mean and variance of all the samples. * @sa Stat, DistBase, FancyStor */ -template <typename T = Counter, class Bin = DefaultBin> +template <class Bin = DefaultBin> class StandardDeviation - : public Wrap<StandardDeviation<T, Bin>, - DistBase<T, FancyStor, Bin>, - DistData> + : public Wrap<StandardDeviation<Bin>, + DistBase<FancyStor, Bin>, + DistStatData> { public: /** The base implementation */ - typedef DistBase<T, DistStor, Bin> Base; + typedef DistBase<DistStor, Bin> Base; /** The parameter type. */ - typedef typename DistStor<T>::Params Params; + typedef typename DistStor::Params Params; public: /** @@ -2698,17 +2385,17 @@ class StandardDeviation * Calculates the per cycle mean and variance of the samples. * @sa Stat, DistBase, AvgFancy */ -template <typename T = Counter, class Bin = DefaultBin> +template <class Bin = DefaultBin> class AverageDeviation - : public Wrap<AverageDeviation<T, Bin>, - DistBase<T, AvgFancy, Bin>, - DistData> + : public Wrap<AverageDeviation<Bin>, + DistBase<AvgFancy, Bin>, + DistStatData> { public: /** The base implementation */ - typedef DistBase<T, DistStor, Bin> Base; + typedef DistBase<DistStor, Bin> Base; /** The parameter type. */ - typedef typename DistStor<T>::Params Params; + typedef typename DistStor::Params Params; public: /** @@ -2725,17 +2412,17 @@ class AverageDeviation * A vector of distributions. * @sa Stat, VectorDistBase, DistStor */ -template <typename T = Counter, class Bin = DefaultBin> +template <class Bin = DefaultBin> class VectorDistribution - : public WrapVec<VectorDistribution<T, Bin>, - VectorDistBase<T, DistStor, Bin>, - VectorDistData> + : public WrapVec<VectorDistribution<Bin>, + VectorDistBase<DistStor, Bin>, + VectorDistStatData> { public: /** The base implementation */ - typedef VectorDistBase<T, DistStor, Bin> Base; + typedef VectorDistBase<DistStor, Bin> Base; /** The parameter type. */ - typedef typename DistStor<T>::Params Params; + typedef typename DistStor::Params Params; public: /** @@ -2746,11 +2433,11 @@ class VectorDistribution * @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) { + VectorDistribution &init(int size, Counter min, Counter max, Counter bkt) { params.min = min; params.max = max; params.bucket_size = bkt; - params.size = (max - min) / bkt + 1; + params.size = (int)rint((max - min) / bkt + 1.0); bin.init(size, params); setInit(); @@ -2762,17 +2449,17 @@ class VectorDistribution * This is a vector of StandardDeviation stats. * @sa Stat, VectorDistBase, FancyStor */ -template <typename T = Counter, class Bin = DefaultBin> +template <class Bin = DefaultBin> class VectorStandardDeviation - : public WrapVec<VectorStandardDeviation<T, Bin>, - VectorDistBase<T, FancyStor, Bin>, - VectorDistData> + : public WrapVec<VectorStandardDeviation<Bin>, + VectorDistBase<FancyStor, Bin>, + VectorDistStatData> { public: /** The base implementation */ - typedef VectorDistBase<T, FancyStor, Bin> Base; + typedef VectorDistBase<FancyStor, Bin> Base; /** The parameter type. */ - typedef typename DistStor<T>::Params Params; + typedef typename DistStor::Params Params; public: /** @@ -2792,17 +2479,17 @@ class VectorStandardDeviation * This is a vector of AverageDeviation stats. * @sa Stat, VectorDistBase, AvgFancy */ -template <typename T = Counter, class Bin = DefaultBin> +template <class Bin = DefaultBin> class VectorAverageDeviation - : public WrapVec<VectorAverageDeviation<T, Bin>, - VectorDistBase<T, AvgFancy, Bin>, - VectorDistData> + : public WrapVec<VectorAverageDeviation<Bin>, + VectorDistBase<AvgFancy, Bin>, + VectorDistStatData> { public: /** The base implementation */ - typedef VectorDistBase<T, AvgFancy, Bin> Base; + typedef VectorDistBase<AvgFancy, Bin> Base; /** The parameter type. */ - typedef typename DistStor<T>::Params Params; + typedef typename DistStor::Params Params; public: /** @@ -2838,7 +2525,7 @@ class FormulaBase : public DataAccess * be x[0]/y, x[1]/y, x[2]/y, respectively. * @return The result vector. */ - void val(rvec_t &vec) const; + void result(VResult &vec) const; /** * Return the total Formula result. If there is a Vector @@ -2847,10 +2534,10 @@ class FormulaBase : public DataAccess * 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. + * the first entry in the VResult val() returns. * @return The total of the result vector. */ - result_t total() const; + Result total() const; /** * Return the number of elements in the tree. @@ -2884,39 +2571,41 @@ class FormulaBase : public DataAccess std::string str() const; }; -class FormulaDataBase : public VectorDataBase +class FormulaData : public VectorData { public: virtual std::string str() const = 0; virtual bool check() const { return true; } - virtual void python(Python &py) const; }; -template <class T> -class FormulaData : public FormulaDataBase +template <class Stat> +class FormulaStatData : public FormulaData { protected: - T &s; - mutable rvec_t vec; + Stat &s; + mutable VResult vec; + mutable VCounter cvec; public: - FormulaData(T &stat) : s(stat) {} + FormulaStatData(Stat &stat) : s(stat) {} virtual bool binned() const { return s.binned(); } virtual bool zero() const { return s.zero(); } virtual void reset() { s.reset(); } virtual size_t size() const { return s.size(); } - virtual const rvec_t &val() const + virtual const VResult &result() const { - s.val(vec); + s.result(vec); return vec; } - virtual result_t total() const { return s.total(); } - virtual void update() + virtual Result total() const { return s.total(); } + virtual VCounter &value() const { return cvec; } + virtual void visit(Visit &visitor) { - VectorDataBase::update(); + update(); s.update(this); + visitor.visit(*this); } virtual std::string str() const { return s.str(); } }; @@ -2925,7 +2614,7 @@ class Temp; class Formula : public WrapVec<Formula, FormulaBase, - FormulaData> + FormulaStatData> { public: /** @@ -2959,14 +2648,14 @@ class FormulaNode : public Node { private: const Formula &formula; - mutable rvec_t vec; + mutable VResult vec; public: FormulaNode(const Formula &f) : formula(f) {} virtual size_t size() const { return formula.size(); } - virtual const rvec_t &val() const { formula.val(vec); return vec; } - virtual result_t total() const { return formula.total(); } + virtual const VResult &result() const { formula.result(vec); return vec; } + virtual Result total() const { return formula.total(); } virtual bool binned() const { return formula.binned(); } virtual std::string str() const { return formula.str(); } @@ -3001,24 +2690,24 @@ class Temp * Create a new ScalarStatNode. * @param s The ScalarStat to place in a node. */ - template <typename T, class Bin> - Temp(const Scalar<T, Bin> &s) + template <class Bin> + Temp(const Scalar<Bin> &s) : node(new ScalarStatNode(s.statData())) { } /** * Create a new ScalarStatNode. * @param s The ScalarStat to place in a node. */ - template <typename T, class Bin> - Temp(const Average<T, Bin> &s) + template <class Bin> + Temp(const Average<Bin> &s) : node(new ScalarStatNode(s.statData())) { } /** * Create a new VectorStatNode. * @param s The VectorStat to place in a node. */ - template <typename T, class Bin> - Temp(const Vector<T, Bin> &s) + template <class Bin> + Temp(const Vector<Bin> &s) : node(new VectorStatNode(s.statData())) { } /** @@ -3031,9 +2720,9 @@ class Temp * 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)) { } + template <class Storage, class Bin> + Temp(const ScalarProxy<Storage, Bin> &p) + : node(new ScalarProxyNode<Storage, Bin>(p)) { } /** * Create a ConstNode @@ -3126,46 +2815,43 @@ class Temp */ void check(); -void dump(std::ostream &stream, DisplayMode mode = DefaultMode); -void python_start(const std::string &file); -void python_dump(const std::string &name, const std::string &subname); void reset(); void registerResetCallback(Callback *cb); inline Temp operator+(Temp l, Temp r) { - return NodePtr(new BinaryNode<std::plus<result_t> >(l, r)); + return NodePtr(new BinaryNode<std::plus<Result> >(l, r)); } inline Temp operator-(Temp l, Temp r) { - return NodePtr(new BinaryNode<std::minus<result_t> >(l, r)); + return NodePtr(new BinaryNode<std::minus<Result> >(l, r)); } inline Temp operator*(Temp l, Temp r) { - return NodePtr(new BinaryNode<std::multiplies<result_t> >(l, r)); + return NodePtr(new BinaryNode<std::multiplies<Result> >(l, r)); } inline Temp operator/(Temp l, Temp r) { - return NodePtr(new BinaryNode<std::divides<result_t> >(l, r)); + return NodePtr(new BinaryNode<std::divides<Result> >(l, r)); } inline Temp operator%(Temp l, Temp r) { - return NodePtr(new BinaryNode<std::modulus<result_t> >(l, r)); + return NodePtr(new BinaryNode<std::modulus<Result> >(l, r)); } inline Temp operator-(Temp l) { - return NodePtr(new UnaryNode<std::negate<result_t> >(l)); + return NodePtr(new UnaryNode<std::negate<Result> >(l)); } template <typename T> @@ -3192,10 +2878,9 @@ scalar(T &val) inline Temp sum(Temp val) { - return NodePtr(new SumNode<std::plus<result_t> >(val)); + return NodePtr(new SumNode<std::plus<Result> >(val)); } -extern bool PrintDescriptions; -} // namespace statistics +/* namespace Statistics */ } -#endif // __STATISTICS_HH__ +#endif // __BASE_STATISTICS_HH__ |