Major stats package cleanup

Add support for generic visitors for stats and use them
to implement independent output functions.

Support for mysql output and some initial code for hacking
on mysql output with python

arch/alpha/pseudo_inst.cc:
base/hybrid_pred.cc:
base/hybrid_pred.hh:
base/sat_counter.cc:
base/sat_counter.hh:
cpu/simple_cpu/simple_cpu.cc:
kern/tru64/tru64_events.cc:
sim/main.cc:
sim/process.cc:
sim/process.hh:
sim/sim_events.cc:
sim/sim_object.cc:
sim/system.hh:
    update for changes in stats package
base/statistics.cc:
    move the python output code to base/stats/puthon.(cc|hh)
    and reimplement it as a visitor.

    move the text output code to base/stats/text.(cc|hh) and
    reimplement it as a visitor.

    move the database stuff into base/stats/statdb.(cc|hh) and
    get rid of the class.  Put everything as globals in the
    Statistics::Database namespace.

    allocate unique ids for all stats.

    directly implement the check routine and get rid of the
    various dumping routines since they're now in separate files.

    make sure that no two stats have the same name

    clean up some loops
base/statistics.hh:
    major changes to the statistics package again

    lots of code was factored out of statistics.hh into several
    separate files in base/stats/ (this will continue)

    There are now two Stat package types Result and Counter that
    are specified to allow the user to keep the counted type
    separate from the result type.  They are currently both doubles
    but that's an experiment.  There is no more per stat ability to
    set the type.  Statistics::Counter is not the same as Counter!

    Implement a visitor for statistics output so that new output
    types can be implemented independently from the stats package
    itself.

    Add a unique id to each stat so that it can be used to keep
    track of stats more simply.  This number can also be used in
    debugging problems with stats.

    Tweak the bucket size stuff a bit to make it work better.

    fixed VectorDist size bug
cpu/memtest/memtest.cc:
    Fix up for changes in stats package
    Don't use value() since it doesn't work with binning.  If you
    want a number as a stat, and to use it in the program itself,
    you really want two separate variables, one that's a stat,
    and one that's not.
cpu/memtest/memtest.hh:
    Fix up for changes in stats package
test/Makefile:
    Try to build stuff now that directories matter
test/stattest.cc:
    test all new output types
    choose which one with command line options

--HG--
extra : convert_revision : e3a3f5f0828c67c0e2de415d936ad240adaddc89

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 *>(&params);
@@ -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 *>(&params);
@@ -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 *>(&params);
@@ -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 &params)
-        : 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 &params)
+    void sample(Counter val, int number, const Params &params)
     {
         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 &params) const
     {
-        return samples == 0;
+        return samples == Counter();
     }
 
     void update(DistDataData *data, const Params &params)
@@ -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 &params) const { return sum == 0; }
+    bool zero(const Params &params) 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 *>(&params);
@@ -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 *>(&params);
@@ -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 &params) { }
-
-        int size() const { return 1; }
-
-        Storage *
-        data(Params &params)
-        {
-            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 &params)
-        {
-            assert(!initialized());
-            assert(s > 0);
-            _size = s;
-            allocate(_size * sizeof(Storage));
-        }
-
-        int size() const { return _size; }
-
-        Storage *data(int index, Params &params)
-        {
-            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 &params)
-        {
-            new (ptr) Storage(params);
-        }
-        int size() const{ return 1; }
-        Storage *data(Params &params)
-        {
-            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 &params)
-        {
-            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 &params)
-        {
-            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__