statistics.hh

Go to the documentation of this file.

/*
 * Copyright (c) 2019-2020 Arm Limited
 * All rights reserved.
 *
 * The license below extends only to copyright in the software and shall
 * not be construed as granting a license to any other intellectual
 * property including but not limited to intellectual property relating
 * to a hardware implementation of the functionality of the software
 * licensed hereunder.  You may use the software subject to the license
 * terms below provided that you ensure that this notice is replicated
 * unmodified and in its entirety in all distributions of the software,
 * modified or unmodified, in source code or in binary form.
 *
 * Copyright (c) 2003-2005 The Regents of The University of Michigan
 * Copyright (c) 2017, Centre National de la Recherche Scientifique
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met: redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer;
 * redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution;
 * neither the name of the copyright holders nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef __BASE_STATISTICS_HH__
#define __BASE_STATISTICS_HH__
 
#include <algorithm>
#include <cassert>
#ifdef __SUNPRO_CC
#include <math.h>
#endif
#include <cmath>
#include <functional>
#include <iosfwd>
#include <list>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#include "base/stats/group.hh"
#include "base/stats/info.hh"
#include "base/stats/output.hh"
#include "base/stats/types.hh"
#include "base/cast.hh"
#include "base/cprintf.hh"
#include "base/intmath.hh"
#include "base/str.hh"
#include "base/types.hh"
 
extern Tick curTick();
 
/* A namespace for all of the Statistics */
namespace Stats {
 
template <class Stat, class Base>
class InfoProxy : public Base
{
  protected:
    Stat &s;
 
  public:
    InfoProxy(Stat &stat) : s(stat) {}
 
    bool check() const { return s.check(); }
    void prepare() { s.prepare(); }
    void reset() { s.reset(); }
    void
    visit(Output &visitor)
    {
        visitor.visit(*static_cast<Base *>(this));
    }
    bool zero() const { return s.zero(); }
};
 
template <class Stat>
class ScalarInfoProxy : public InfoProxy<Stat, ScalarInfo>
{
  public:
    ScalarInfoProxy(Stat &stat) : InfoProxy<Stat, ScalarInfo>(stat) {}
 
    Counter value() const { return this->s.value(); }
    Result result() const { return this->s.result(); }
    Result total() const { return this->s.total(); }
};
 
template <class Stat>
class VectorInfoProxy : public InfoProxy<Stat, VectorInfo>
{
  protected:
    mutable VCounter cvec;
    mutable VResult rvec;
 
  public:
    VectorInfoProxy(Stat &stat) : InfoProxy<Stat, VectorInfo>(stat) {}
 
    size_type size() const { return this->s.size(); }
 
    VCounter &
    value() const
    {
        this->s.value(cvec);
        return cvec;
    }
 
    const VResult &
    result() const
    {
        this->s.result(rvec);
        return rvec;
    }
 
    Result total() const { return this->s.total(); }
};
 
template <class Stat>
class DistInfoProxy : public InfoProxy<Stat, DistInfo>
{
  public:
    DistInfoProxy(Stat &stat) : InfoProxy<Stat, DistInfo>(stat) {}
};
 
template <class Stat>
class VectorDistInfoProxy : public InfoProxy<Stat, VectorDistInfo>
{
  public:
    VectorDistInfoProxy(Stat &stat) : InfoProxy<Stat, VectorDistInfo>(stat) {}
 
    size_type size() const { return this->s.size(); }
};
 
template <class Stat>
class Vector2dInfoProxy : public InfoProxy<Stat, Vector2dInfo>
{
  public:
    Vector2dInfoProxy(Stat &stat) : InfoProxy<Stat, Vector2dInfo>(stat) {}
 
    Result total() const { return this->s.total(); }
};
 
struct StorageParams
{
    virtual ~StorageParams();
};
 
class InfoAccess
{
  private:
    Info *_info;
 
  protected:
    void setInfo(Group *parent, Info *info);
    void setParams(const StorageParams *params);
    void setInit();
 
    Info *info();
    const Info *info() const;
 
  public:
    InfoAccess()
        : _info(nullptr) {};
 
    void reset() { }
 
    bool zero() const { return true; }
 
    bool check() const { return true; }
};
 
template <class Derived, template <class> class InfoProxyType>
class DataWrap : public InfoAccess
{
  public:
    typedef InfoProxyType<Derived> Info;
 
  protected:
    Derived &self() { return *static_cast<Derived *>(this); }
 
  protected:
    Info *
    info()
    {
        return safe_cast<Info *>(InfoAccess::info());
    }
 
  public:
    const Info *
    info() const
    {
        return safe_cast<const Info *>(InfoAccess::info());
    }
 
  public:
    DataWrap() = delete;
    DataWrap(const DataWrap &) = delete;
    DataWrap &operator=(const DataWrap &) = delete;
 
 
    DataWrap(Group *parent, const char *name, const char *desc)
    {
        auto info = new Info(self());
        this->setInfo(parent, info);
 
        if (parent)
            parent->addStat(info);
 
        if (name) {
            info->setName(parent, name);
            info->flags.set(display);
        }
 
        if (desc)
            info->desc = desc;
    }
 
    Derived &
    name(const std::string &name)
    {
        Info *info = this->info();
        info->setName(name);
        info->flags.set(display);
        return this->self();
    }
    const std::string &name() const { return this->info()->name; }
 
    Derived &
    setSeparator(const std::string &_sep)
    {
      this->info()->setSeparator(_sep);
      return this->self();
    }
    const std::string &setSeparator() const
    {
      return this->info()->separatorString;
    }
 
    Derived &
    desc(const std::string &_desc)
    {
        this->info()->desc = _desc;
        return this->self();
    }
 
    Derived &
    precision(int _precision)
    {
        this->info()->precision = _precision;
        return this->self();
    }
 
    Derived &
    flags(Flags _flags)
    {
        this->info()->flags.set(_flags);
        return this->self();
    }
 
    template <class Stat>
    Derived &
    prereq(const Stat &prereq)
    {
        this->info()->prereq = prereq.info();
        return this->self();
    }
};
 
template <class Derived, template <class> class InfoProxyType>
class DataWrapVec : public DataWrap<Derived, InfoProxyType>
{
  public:
    typedef InfoProxyType<Derived> Info;
 
    DataWrapVec(Group *parent = nullptr, const char *name = nullptr,
                const char *desc = nullptr)
        : DataWrap<Derived, InfoProxyType>(parent, name, desc)
    {}
 
    // The following functions are specific to vectors.  If you use them
    // in a non vector context, you will get a nice compiler error!
 
    Derived &
    subname(off_type index, const std::string &name)
    {
        Derived &self = this->self();
        Info *info = self.info();
 
        std::vector<std::string> &subn = info->subnames;
        if (subn.size() <= index)
            subn.resize(index + 1);
        subn[index] = name;
        return self;
    }
 
    // The following functions are specific to 2d vectors.  If you use
    // them in a non vector context, you will get a nice compiler
    // error because info doesn't have the right variables.
 
    Derived &
    subdesc(off_type index, const std::string &desc)
    {
        Info *info = this->info();
 
        std::vector<std::string> &subd = info->subdescs;
        if (subd.size() <= index)
            subd.resize(index + 1);
        subd[index] = desc;
 
        return this->self();
    }
 
    void
    prepare()
    {
        Derived &self = this->self();
        Info *info = this->info();
 
        size_t size = self.size();
        for (off_type i = 0; i < size; ++i)
            self.data(i)->prepare(info);
    }
 
    void
    reset()
    {
        Derived &self = this->self();
        Info *info = this->info();
 
        size_t size = self.size();
        for (off_type i = 0; i < size; ++i)
            self.data(i)->reset(info);
    }
};
 
template <class Derived, template <class> class InfoProxyType>
class DataWrapVec2d : public DataWrapVec<Derived, InfoProxyType>
{
  public:
    typedef InfoProxyType<Derived> Info;
 
    DataWrapVec2d(Group *parent, const char *name, const char *desc)
        : DataWrapVec<Derived, InfoProxyType>(parent, name, desc)
    {
    }
 
    Derived &
    ysubnames(const char **names)
    {
        Derived &self = this->self();
        Info *info = this->info();
 
        info->y_subnames.resize(self.y);
        for (off_type i = 0; i < self.y; ++i)
            info->y_subnames[i] = names[i];
        return self;
    }
 
    Derived &
    ysubname(off_type index, const std::string &subname)
    {
        Derived &self = this->self();
        Info *info = this->info();
 
        assert(index < self.y);
        info->y_subnames.resize(self.y);
        info->y_subnames[index] = subname.c_str();
        return self;
    }
 
    std::string
    ysubname(off_type i) const
    {
        return this->info()->y_subnames[i];
    }
 
};
 
//
// Simple Statistics
//
 
class StatStor
{
  private:
    Counter data;
 
  public:
    struct Params : public StorageParams {};
 
  public:
    StatStor(Info *info)
        : data(Counter())
    { }
 
    void set(Counter val) { data = val; }
    void inc(Counter val) { data += val; }
    void dec(Counter val) { data -= val; }
    Counter value() const { return data; }
    Result result() const { return (Result)data; }
    void prepare(Info *info) { }
    void reset(Info *info) { data = Counter(); }
 
    bool zero() const { return data == Counter(); }
};
 
class AvgStor
{
  private:
    Counter current;
    Tick lastReset;
    mutable Result total;
    mutable Tick last;
 
  public:
    struct Params : public StorageParams {};
 
  public:
    AvgStor(Info *info)
        : current(0), lastReset(0), total(0), last(0)
    { }
 
    void
    set(Counter val)
    {
        total += current * (curTick() - last);
        last = curTick();
        current = val;
    }
 
    void inc(Counter val) { set(current + val); }
 
    void dec(Counter val) { set(current - val); }
 
    Counter value() const { return current; }
 
    Result
    result() const
    {
        assert(last == curTick());
        return (Result)(total + current) / (Result)(curTick() - lastReset + 1);
    }
 
    bool zero() const { return total == 0.0; }
 
    void
    prepare(Info *info)
    {
        total += current * (curTick() - last);
        last = curTick();
    }
 
    void
    reset(Info *info)
    {
        total = 0.0;
        last = curTick();
        lastReset = curTick();
    }
 
};
 
template <class Derived, class Stor>
class ScalarBase : public DataWrap<Derived, ScalarInfoProxy>
{
  public:
    typedef Stor Storage;
    typedef typename Stor::Params Params;
 
  protected:
    char storage[sizeof(Storage)] __attribute__ ((aligned (8)));
 
  protected:
    Storage *
    data()
    {
        return reinterpret_cast<Storage *>(storage);
    }
 
    const Storage *
    data() const
    {
        return reinterpret_cast<const Storage *>(storage);
    }
 
    void
    doInit()
    {
        new (storage) Storage(this->info());
        this->setInit();
    }
 
  public:
    Counter value() const { return data()->value(); }
 
  public:
    ScalarBase(Group *parent = nullptr, const char *name = nullptr,
               const char *desc = nullptr)
        : DataWrap<Derived, ScalarInfoProxy>(parent, name, desc)
    {
        this->doInit();
    }
 
  public:
    // Common operators for stats
    void operator++() { data()->inc(1); }
    void operator--() { data()->dec(1); }
 
    void operator++(int) { ++*this; }
    void operator--(int) { --*this; }
 
    template <typename U>
    void operator=(const U &v) { data()->set(v); }
 
    template <typename U>
    void operator+=(const U &v) { data()->inc(v); }
 
    template <typename U>
    void operator-=(const U &v) { data()->dec(v); }
 
    size_type size() const { return 1; }
 
    Counter value() { return data()->value(); }
 
    Result result() { return data()->result(); }
 
    Result total() { return result(); }
 
    bool zero() { return result() == 0.0; }
 
    void reset() { data()->reset(this->info()); }
    void prepare() { data()->prepare(this->info()); }
};
 
class ProxyInfo : public ScalarInfo
{
  public:
    std::string str() const { return std::to_string(value()); }
    size_type size() const { return 1; }
    bool check() const { return true; }
    void prepare() { }
    void reset() { }
    bool zero() const { return value() == 0; }
 
    void visit(Output &visitor) { visitor.visit(*this); }
};
 
template <class T>
class ValueProxy : public ProxyInfo
{
  private:
    T *scalar;
 
  public:
    ValueProxy(T &val) : scalar(&val) {}
    Counter value() const { return *scalar; }
    Result result() const { return *scalar; }
    Result total() const { return *scalar; }
};
 
template <class T, class Enabled=void>
class FunctorProxy : public ProxyInfo
{
  private:
    T *functor;
 
  public:
    FunctorProxy(T &func) : functor(&func) {}
    Counter value() const { return (*functor)(); }
    Result result() const { return (*functor)(); }
    Result total() const { return (*functor)(); }
};
 
template <class T>
class FunctorProxy<T,
    typename std::enable_if<std::is_constructible<std::function<Result()>,
        const T &>::value>::type> : public ProxyInfo
{
  private:
    std::function<Result()> functor;
 
  public:
    FunctorProxy(const T &func) : functor(func) {}
    Counter value() const { return functor(); }
    Result result() const { return functor(); }
    Result total() const { return functor(); }
};
 
template <class T, class V>
class MethodProxy : public ProxyInfo
{
  private:
    T *object;
    typedef V (T::*MethodPointer) () const;
    MethodPointer method;
 
  public:
    MethodProxy(T *obj, MethodPointer meth) : object(obj), method(meth) {}
    Counter value() const { return (object->*method)(); }
    Result result() const { return (object->*method)(); }
    Result total() const { return (object->*method)(); }
};
 
template <class Derived>
class ValueBase : public DataWrap<Derived, ScalarInfoProxy>
{
  private:
    ProxyInfo *proxy;
 
  public:
    ValueBase(Group *parent, const char *name, const char *desc)
        : DataWrap<Derived, ScalarInfoProxy>(parent, name, desc),
          proxy(NULL)
    {
    }
 
    ~ValueBase() { if (proxy) delete proxy; }
 
    template <class T>
    Derived &
    scalar(T &value)
    {
        proxy = new ValueProxy<T>(value);
        this->setInit();
        return this->self();
    }
 
    template <class T>
    Derived &
    functor(const T &func)
    {
        proxy = new FunctorProxy<T>(func);
        this->setInit();
        return this->self();
    }
 
    template <class T>
    Derived &
    functor(T &func)
    {
        proxy = new FunctorProxy<T>(func);
        this->setInit();
        return this->self();
    }
 
    template <class T, class V>
    Derived &
    method(T *obj,  V (T::*method)() const)
    {
        proxy = new MethodProxy<T,V>(obj, method);
        this->setInit();
        return this->self();
    }
 
    Counter value() { return proxy->value(); }
    Result result() const { return proxy->result(); }
    Result total() const { return proxy->total(); };
    size_type size() const { return proxy->size(); }
 
    std::string str() const { return proxy->str(); }
    bool zero() const { return proxy->zero(); }
    bool check() const { return proxy != NULL; }
    void prepare() { }
    void reset() { }
};
 
//
// Vector Statistics
//
 
template <class Stat>
class ScalarProxy
{
  private:
    Stat &stat;
 
    off_type index;
 
  public:
    Counter value() const { return stat.data(index)->value(); }
 
    Result result() const { return stat.data(index)->result(); }
 
  public:
    ScalarProxy(Stat &s, off_type i)
        : stat(s), index(i)
    {
    }
 
    ScalarProxy(const ScalarProxy &sp)
        : stat(sp.stat), index(sp.index)
    {}
 
    const ScalarProxy &
    operator=(const ScalarProxy &sp)
    {
        stat = sp.stat;
        index = sp.index;
        return *this;
    }
 
  public:
    // Common operators for stats
    void operator++() { stat.data(index)->inc(1); }
    void operator--() { stat.data(index)->dec(1); }
 
    void operator++(int) { ++*this; }
    void operator--(int) { --*this; }
 
    template <typename U>
    void
    operator=(const U &v)
    {
        stat.data(index)->set(v);
    }
 
    template <typename U>
    void
    operator+=(const U &v)
    {
        stat.data(index)->inc(v);
    }
 
    template <typename U>
    void
    operator-=(const U &v)
    {
        stat.data(index)->dec(v);
    }
 
    size_type size() const { return 1; }
 
  public:
    std::string
    str() const
    {
        return csprintf("%s[%d]", stat.info()->name, index);
    }
};
 
template <class Derived, class Stor>
class VectorBase : public DataWrapVec<Derived, VectorInfoProxy>
{
  public:
    typedef Stor Storage;
    typedef typename Stor::Params Params;
 
    typedef ScalarProxy<Derived> Proxy;
    friend class ScalarProxy<Derived>;
    friend class DataWrapVec<Derived, VectorInfoProxy>;
 
  protected:
    Storage *storage;
    size_type _size;
 
  protected:
    Storage *data(off_type index) { return &storage[index]; }
 
    const Storage *data(off_type index) const { return &storage[index]; }
 
    void
    doInit(size_type s)
    {
        assert(s > 0 && "size must be positive!");
        assert(!storage && "already initialized");
        _size = s;
 
        char *ptr = new char[_size * sizeof(Storage)];
        storage = reinterpret_cast<Storage *>(ptr);
 
        for (off_type i = 0; i < _size; ++i)
            new (&storage[i]) Storage(this->info());
 
        this->setInit();
    }
 
  public:
    void
    value(VCounter &vec) const
    {
        vec.resize(size());
        for (off_type i = 0; i < size(); ++i)
            vec[i] = data(i)->value();
    }
 
    void
    result(VResult &vec) const
    {
        vec.resize(size());
        for (off_type i = 0; i < size(); ++i)
            vec[i] = data(i)->result();
    }
 
    Result
    total() const
    {
        Result total = 0.0;
        for (off_type i = 0; i < size(); ++i)
            total += data(i)->result();
        return total;
    }
 
    size_type size() const { return _size; }
 
    bool
    zero() const
    {
        for (off_type i = 0; i < size(); ++i)
            if (data(i)->zero())
                return false;
        return true;
    }
 
    bool
    check() const
    {
        return storage != NULL;
    }
 
  public:
    VectorBase(Group *parent, const char *name, const char *desc)
        : DataWrapVec<Derived, VectorInfoProxy>(parent, name, desc),
          storage(nullptr), _size(0)
    {}
 
    ~VectorBase()
    {
        if (!storage)
            return;
 
        for (off_type i = 0; i < _size; ++i)
            data(i)->~Storage();
        delete [] reinterpret_cast<char *>(storage);
    }
 
    Derived &
    init(size_type size)
    {
        Derived &self = this->self();
        self.doInit(size);
        return self;
    }
 
    Proxy
    operator[](off_type index)
    {
        assert (index < size());
        return Proxy(this->self(), index);
    }
};
 
template <class Stat>
class VectorProxy
{
  private:
    Stat &stat;
    off_type offset;
    size_type len;
 
  private:
    mutable VResult vec;
 
    typename Stat::Storage *
    data(off_type index)
    {
        assert(index < len);
        return stat.data(offset + index);
    }
 
    const typename Stat::Storage *
    data(off_type index) const
    {
        assert(index < len);
        return stat.data(offset + index);
    }
 
  public:
    const VResult &
    result() const
    {
        vec.resize(size());
 
        for (off_type i = 0; i < size(); ++i)
            vec[i] = data(i)->result();
 
        return vec;
    }
 
    Result
    total() const
    {
        Result total = 0.0;
        for (off_type i = 0; i < size(); ++i)
            total += data(i)->result();
        return total;
    }
 
  public:
    VectorProxy(Stat &s, off_type o, size_type l)
        : stat(s), offset(o), len(l)
    {
    }
 
    VectorProxy(const VectorProxy &sp)
        : stat(sp.stat), offset(sp.offset), len(sp.len)
    {
    }
 
    const VectorProxy &
    operator=(const VectorProxy &sp)
    {
        stat = sp.stat;
        offset = sp.offset;
        len = sp.len;
        return *this;
    }
 
    ScalarProxy<Stat>
    operator[](off_type index)
    {
        assert (index < size());
        return ScalarProxy<Stat>(stat, offset + index);
    }
 
    size_type size() const { return len; }
};
 
template <class Derived, class Stor>
class Vector2dBase : public DataWrapVec2d<Derived, Vector2dInfoProxy>
{
  public:
    typedef Vector2dInfoProxy<Derived> Info;
    typedef Stor Storage;
    typedef typename Stor::Params Params;
    typedef VectorProxy<Derived> Proxy;
    friend class ScalarProxy<Derived>;
    friend class VectorProxy<Derived>;
    friend class DataWrapVec<Derived, Vector2dInfoProxy>;
    friend class DataWrapVec2d<Derived, Vector2dInfoProxy>;
 
  protected:
    size_type x;
    size_type y;
    size_type _size;
    Storage *storage;
 
  protected:
    Storage *data(off_type index) { return &storage[index]; }
    const Storage *data(off_type index) const { return &storage[index]; }
 
  public:
    Vector2dBase(Group *parent, const char *name, const char *desc)
        : DataWrapVec2d<Derived, Vector2dInfoProxy>(parent, name, desc),
          x(0), y(0), _size(0), storage(nullptr)
    {}
 
    ~Vector2dBase()
    {
        if (!storage)
            return;
 
        for (off_type i = 0; i < _size; ++i)
            data(i)->~Storage();
        delete [] reinterpret_cast<char *>(storage);
    }
 
    Derived &
    init(size_type _x, size_type _y)
    {
        assert(_x > 0 && _y > 0 && "sizes must be positive!");
        assert(!storage && "already initialized");
 
        Derived &self = this->self();
        Info *info = this->info();
 
        x = _x;
        y = _y;
        info->x = _x;
        info->y = _y;
        _size = x * y;
 
        char *ptr = new char[_size * sizeof(Storage)];
        storage = reinterpret_cast<Storage *>(ptr);
 
        for (off_type i = 0; i < _size; ++i)
            new (&storage[i]) Storage(info);
 
        this->setInit();
 
        return self;
    }
 
    Proxy
    operator[](off_type index)
    {
        off_type offset = index * y;
        assert (offset + y <= size());
        return Proxy(this->self(), offset, y);
    }
 
 
    size_type
    size() const
    {
        return _size;
    }
 
    bool
    zero() const
    {
        return data(0)->zero();
    }
 
    Result
    total() const
    {
        Result total = 0.0;
        for (off_type i = 0; i < size(); ++i)
            total += data(i)->result();
        return total;
    }
 
    void
    prepare()
    {
        Info *info = this->info();
        size_type size = this->size();
 
        for (off_type i = 0; i < size; ++i)
            data(i)->prepare(info);
 
        info->cvec.resize(size);
        for (off_type i = 0; i < size; ++i)
            info->cvec[i] = data(i)->value();
    }
 
    void
    reset()
    {
        Info *info = this->info();
        size_type size = this->size();
        for (off_type i = 0; i < size; ++i)
            data(i)->reset(info);
    }
 
    bool
    check() const
    {
        return storage != NULL;
    }
};
 
//
// Non formula statistics
//
 
struct DistParams : public StorageParams
{
    const DistType type;
    DistParams(DistType t) : type(t) {}
};
 
class DistStor
{
  public:
    struct Params : public DistParams
    {
        Counter min;
        Counter max;
        Counter bucket_size;
        size_type buckets;
 
        Params() : DistParams(Dist), min(0), max(0), bucket_size(0),
                   buckets(0) {}
    };
 
  private:
    Counter min_track;
    Counter max_track;
    Counter bucket_size;
 
    Counter min_val;
    Counter max_val;
    Counter underflow;
    Counter overflow;
    Counter sum;
    Counter squares;
    Counter samples;
    VCounter cvec;
 
  public:
    DistStor(Info *info)
        : cvec(safe_cast<const Params *>(info->storageParams)->buckets)
    {
        reset(info);
    }
 
    void
    sample(Counter val, int number)
    {
        if (val < min_track)
            underflow += number;
        else if (val > max_track)
            overflow += number;
        else {
            size_type index =
                (size_type)std::floor((val - min_track) / bucket_size);
            assert(index < size());
            cvec[index] += number;
        }
 
        if (val < min_val)
            min_val = val;
 
        if (val > max_val)
            max_val = val;
 
        sum += val * number;
        squares += val * val * number;
        samples += number;
    }
 
    size_type size() const { return cvec.size(); }
 
    bool
    zero() const
    {
        return samples == Counter();
    }
 
    void
    prepare(Info *info, DistData &data)
    {
        const Params *params = safe_cast<const Params *>(info->storageParams);
 
        assert(params->type == Dist);
        data.type = params->type;
        data.min = params->min;
        data.max = params->max;
        data.bucket_size = params->bucket_size;
 
        data.min_val = (min_val == CounterLimits::max()) ? 0 : min_val;
        data.max_val = (max_val == CounterLimits::min()) ? 0 : max_val;
        data.underflow = underflow;
        data.overflow = overflow;
 
        data.cvec.resize(params->buckets);
        for (off_type i = 0; i < params->buckets; ++i)
            data.cvec[i] = cvec[i];
 
        data.sum = sum;
        data.squares = squares;
        data.samples = samples;
    }
 
    void
    reset(Info *info)
    {
        const Params *params = safe_cast<const Params *>(info->storageParams);
        min_track = params->min;
        max_track = params->max;
        bucket_size = params->bucket_size;
 
        min_val = CounterLimits::max();
        max_val = CounterLimits::min();
        underflow = Counter();
        overflow = Counter();
 
        size_type size = cvec.size();
        for (off_type i = 0; i < size; ++i)
            cvec[i] = Counter();
 
        sum = Counter();
        squares = Counter();
        samples = Counter();
    }
};
 
class HistStor
{
  public:
    struct Params : public DistParams
    {
        size_type buckets;
 
        Params() : DistParams(Hist), buckets(0) {}
    };
 
  private:
    Counter min_bucket;
    Counter max_bucket;
    Counter bucket_size;
 
    Counter sum;
    Counter logs;
    Counter squares;
    Counter samples;
    VCounter cvec;
 
  public:
    HistStor(Info *info)
        : cvec(safe_cast<const Params *>(info->storageParams)->buckets)
    {
        reset(info);
    }
 
    void grow_up();
    void grow_out();
    void grow_convert();
    void add(HistStor *);
 
    void
    sample(Counter val, int number)
    {
        assert(min_bucket < max_bucket);
        if (val < min_bucket) {
            if (min_bucket == 0)
                grow_convert();
 
            while (val < min_bucket)
                grow_out();
        } else if (val >= max_bucket + bucket_size) {
            if (min_bucket == 0) {
                while (val >= max_bucket + bucket_size)
                    grow_up();
            } else {
                while (val >= max_bucket + bucket_size)
                    grow_out();
            }
        }
 
        size_type index =
            (int64_t)std::floor((val - min_bucket) / bucket_size);
 
        assert(index < size());
        cvec[index] += number;
 
        sum += val * number;
        squares += val * val * number;
        logs += log(val) * number;
        samples += number;
    }
 
    size_type size() const { return cvec.size(); }
 
    bool
    zero() const
    {
        return samples == Counter();
    }
 
    void
    prepare(Info *info, DistData &data)
    {
        const Params *params = safe_cast<const Params *>(info->storageParams);
 
        assert(params->type == Hist);
        data.type = params->type;
        data.min = min_bucket;
        data.max = max_bucket + bucket_size - 1;
        data.bucket_size = bucket_size;
 
        data.min_val = min_bucket;
        data.max_val = max_bucket;
 
        int buckets = params->buckets;
        data.cvec.resize(buckets);
        for (off_type i = 0; i < buckets; ++i)
            data.cvec[i] = cvec[i];
 
        data.sum = sum;
        data.logs = logs;
        data.squares = squares;
        data.samples = samples;
    }
 
    void
    reset(Info *info)
    {
        const Params *params = safe_cast<const Params *>(info->storageParams);
        min_bucket = 0;
        max_bucket = params->buckets - 1;
        bucket_size = 1;
 
        size_type size = cvec.size();
        for (off_type i = 0; i < size; ++i)
            cvec[i] = Counter();
 
        sum = Counter();
        squares = Counter();
        samples = Counter();
        logs = Counter();
    }
};
 
class SampleStor
{
  public:
    struct Params : public DistParams
    {
        Params() : DistParams(Deviation) {}
    };
 
  private:
    Counter sum;
    Counter squares;
    Counter samples;
 
  public:
    SampleStor(Info *info)
        : sum(Counter()), squares(Counter()), samples(Counter())
    { }
 
    void
    sample(Counter val, int number)
    {
        sum += val * number;
        squares += val * val * number;
        samples += number;
    }
 
    size_type size() const { return 1; }
 
    bool zero() const { return samples == Counter(); }
 
    void
    prepare(Info *info, DistData &data)
    {
        const Params *params = safe_cast<const Params *>(info->storageParams);
 
        assert(params->type == Deviation);
        data.type = params->type;
        data.sum = sum;
        data.squares = squares;
        data.samples = samples;
    }
 
    void
    reset(Info *info)
    {
        sum = Counter();
        squares = Counter();
        samples = Counter();
    }
};
 
class AvgSampleStor
{
  public:
    struct Params : public DistParams
    {
        Params() : DistParams(Deviation) {}
    };
 
  private:
    Counter sum;
    Counter squares;
 
  public:
    AvgSampleStor(Info *info)
        : sum(Counter()), squares(Counter())
    {}
 
    void
    sample(Counter val, int number)
    {
        sum += val * number;
        squares += val * val * number;
    }
 
    size_type size() const { return 1; }
 
    bool zero() const { return sum == Counter(); }
 
    void
    prepare(Info *info, DistData &data)
    {
        const Params *params = safe_cast<const Params *>(info->storageParams);
 
        assert(params->type == Deviation);
        data.type = params->type;
        data.sum = sum;
        data.squares = squares;
        data.samples = curTick();
    }
 
    void
    reset(Info *info)
    {
        sum = Counter();
        squares = Counter();
    }
};
 
template <class Derived, class Stor>
class DistBase : public DataWrap<Derived, DistInfoProxy>
{
  public:
    typedef DistInfoProxy<Derived> Info;
    typedef Stor Storage;
    typedef typename Stor::Params Params;
 
  protected:
    char storage[sizeof(Storage)] __attribute__ ((aligned (8)));
 
  protected:
    Storage *
    data()
    {
        return reinterpret_cast<Storage *>(storage);
    }
 
    const Storage *
    data() const
    {
        return reinterpret_cast<const Storage *>(storage);
    }
 
    void
    doInit()
    {
        new (storage) Storage(this->info());
        this->setInit();
    }
 
  public:
    DistBase(Group *parent, const char *name, const char *desc)
        : DataWrap<Derived, DistInfoProxy>(parent, name, desc)
    {
    }
 
    template <typename U>
    void sample(const U &v, int n = 1) { data()->sample(v, n); }
 
    size_type size() const { return data()->size(); }
    bool zero() const { return data()->zero(); }
 
    void
    prepare()
    {
        Info *info = this->info();
        data()->prepare(info, info->data);
    }
 
    void
    reset()
    {
        data()->reset(this->info());
    }
 
    void add(DistBase &d) { data()->add(d.data()); }
 
};
 
template <class Stat>
class DistProxy;
 
template <class Derived, class Stor>
class VectorDistBase : public DataWrapVec<Derived, VectorDistInfoProxy>
{
  public:
    typedef VectorDistInfoProxy<Derived> Info;
    typedef Stor Storage;
    typedef typename Stor::Params Params;
    typedef DistProxy<Derived> Proxy;
    friend class DistProxy<Derived>;
    friend class DataWrapVec<Derived, VectorDistInfoProxy>;
 
  protected:
    Storage *storage;
    size_type _size;
 
  protected:
    Storage *
    data(off_type index)
    {
        return &storage[index];
    }
 
    const Storage *
    data(off_type index) const
    {
        return &storage[index];
    }
 
    void
    doInit(size_type s)
    {
        assert(s > 0 && "size must be positive!");
        assert(!storage && "already initialized");
        _size = s;
 
        char *ptr = new char[_size * sizeof(Storage)];
        storage = reinterpret_cast<Storage *>(ptr);
 
        Info *info = this->info();
        for (off_type i = 0; i < _size; ++i)
            new (&storage[i]) Storage(info);
 
        this->setInit();
    }
 
  public:
    VectorDistBase(Group *parent, const char *name, const char *desc)
        : DataWrapVec<Derived, VectorDistInfoProxy>(parent, name, desc),
          storage(NULL)
    {}
 
    ~VectorDistBase()
    {
        if (!storage)
            return ;
 
        for (off_type i = 0; i < _size; ++i)
            data(i)->~Storage();
        delete [] reinterpret_cast<char *>(storage);
    }
 
    Proxy operator[](off_type index)
    {
        assert(index < size());
        return Proxy(this->self(), index);
    }
 
    size_type
    size() const
    {
        return _size;
    }
 
    bool
    zero() const
    {
        for (off_type i = 0; i < size(); ++i)
            if (!data(i)->zero())
                return false;
        return true;
    }
 
    void
    prepare()
    {
        Info *info = this->info();
        size_type size = this->size();
        info->data.resize(size);
        for (off_type i = 0; i < size; ++i)
            data(i)->prepare(info, info->data[i]);
    }
 
    bool
    check() const
    {
        return storage != NULL;
    }
};
 
template <class Stat>
class DistProxy
{
  private:
    Stat &stat;
    off_type index;
 
  protected:
    typename Stat::Storage *data() { return stat.data(index); }
    const typename Stat::Storage *data() const { return stat.data(index); }
 
  public:
    DistProxy(Stat &s, off_type i)
        : stat(s), index(i)
    {}
 
    DistProxy(const DistProxy &sp)
        : stat(sp.stat), index(sp.index)
    {}
 
    const DistProxy &
    operator=(const DistProxy &sp)
    {
        stat = sp.stat;
        index = sp.index;
        return *this;
    }
 
  public:
    template <typename U>
    void
    sample(const U &v, int n = 1)
    {
        data()->sample(v, n);
    }
 
    size_type
    size() const
    {
        return 1;
    }
 
    bool
    zero() const
    {
        return data()->zero();
    }
 
    void reset() { }
};
 
//
//  Formula Details
//
 
class Node
{
  public:
    virtual size_type size() const = 0;
    virtual const VResult &result() const = 0;
    virtual Result total() const = 0;
 
    virtual std::string str() const = 0;
 
    virtual ~Node() {};
};
 
typedef std::shared_ptr<Node> NodePtr;
 
class ScalarStatNode : public Node
{
  private:
    const ScalarInfo *data;
    mutable VResult vresult;
 
  public:
    ScalarStatNode(const ScalarInfo *d) : data(d), vresult(1) {}
 
    const VResult &
    result() const
    {
        vresult[0] = data->result();
        return vresult;
    }
 
    Result total() const { return data->result(); };
 
    size_type size() const { return 1; }
 
    std::string str() const { return data->name; }
};
 
template <class Stat>
class ScalarProxyNode : public Node
{
  private:
    const ScalarProxy<Stat> proxy;
    mutable VResult vresult;
 
  public:
    ScalarProxyNode(const ScalarProxy<Stat> &p)
        : proxy(p), vresult(1)
    { }
 
    const VResult &
    result() const
    {
        vresult[0] = proxy.result();
        return vresult;
    }
 
    Result
    total() const
    {
        return proxy.result();
    }
 
    size_type
    size() const
    {
        return 1;
    }
 
    std::string
    str() const
    {
        return proxy.str();
    }
};
 
class VectorStatNode : public Node
{
  private:
    const VectorInfo *data;
 
  public:
    VectorStatNode(const VectorInfo *d) : data(d) { }
    const VResult &result() const { return data->result(); }
    Result total() const { return data->total(); };
 
    size_type size() const { return data->size(); }
 
    std::string str() const { return data->name; }
};
 
template <class T>
class ConstNode : public Node
{
  private:
    VResult vresult;
 
  public:
    ConstNode(T s) : vresult(1, (Result)s) {}
    const VResult &result() const { return vresult; }
    Result total() const { return vresult[0]; };
    size_type size() const { return 1; }
    std::string str() const { return std::to_string(vresult[0]); }
};
 
template <class T>
class ConstVectorNode : public Node
{
  private:
    VResult vresult;
 
  public:
    ConstVectorNode(const T &s) : vresult(s.begin(), s.end()) {}
    const VResult &result() const { return vresult; }
 
    Result
    total() const
    {
        size_type size = this->size();
        Result tmp = 0;
        for (off_type i = 0; i < size; i++)
            tmp += vresult[i];
        return tmp;
    }
 
    size_type size() const { return vresult.size(); }
    std::string
    str() const
    {
        size_type size = this->size();
        std::string tmp = "(";
        for (off_type i = 0; i < size; i++)
            tmp += csprintf("%s ", std::to_string(vresult[i]));
        tmp += ")";
        return tmp;
    }
};
 
template <class Op>
struct OpString;
 
template<>
struct OpString<std::plus<Result> >
{
    static std::string str() { return "+"; }
};
 
template<>
struct OpString<std::minus<Result> >
{
    static std::string str() { return "-"; }
};
 
template<>
struct OpString<std::multiplies<Result> >
{
    static std::string str() { return "*"; }
};
 
template<>
struct OpString<std::divides<Result> >
{
    static std::string str() { return "/"; }
};
 
template<>
struct OpString<std::modulus<Result> >
{
    static std::string str() { return "%"; }
};
 
template<>
struct OpString<std::negate<Result> >
{
    static std::string str() { return "-"; }
};
 
template <class Op>
class UnaryNode : public Node
{
  public:
    NodePtr l;
    mutable VResult vresult;
 
  public:
    UnaryNode(NodePtr &p) : l(p) {}
 
    const VResult &
    result() const
    {
        const VResult &lvec = l->result();
        size_type size = lvec.size();
 
        assert(size > 0);
 
        vresult.resize(size);
        Op op;
        for (off_type i = 0; i < size; ++i)
            vresult[i] = op(lvec[i]);
 
        return vresult;
    }
 
    Result
    total() const
    {
        const VResult &vec = this->result();
        Result total = 0.0;
        for (off_type i = 0; i < size(); i++)
            total += vec[i];
        return total;
    }
 
    size_type size() const { return l->size(); }
 
    std::string
    str() const
    {
        return OpString<Op>::str() + l->str();
    }
};
 
template <class Op>
class BinaryNode : public Node
{
  public:
    NodePtr l;
    NodePtr r;
    mutable VResult vresult;
 
  public:
    BinaryNode(NodePtr &a, NodePtr &b) : l(a), r(b) {}
 
    const VResult &
    result() const override
    {
        Op op;
        const VResult &lvec = l->result();
        const VResult &rvec = r->result();
 
        assert(lvec.size() > 0 && rvec.size() > 0);
 
        if (lvec.size() == 1 && rvec.size() == 1) {
            vresult.resize(1);
            vresult[0] = op(lvec[0], rvec[0]);
        } else if (lvec.size() == 1) {
            size_type size = rvec.size();
            vresult.resize(size);
            for (off_type i = 0; i < size; ++i)
                vresult[i] = op(lvec[0], rvec[i]);
        } else if (rvec.size() == 1) {
            size_type size = lvec.size();
            vresult.resize(size);
            for (off_type i = 0; i < size; ++i)
                vresult[i] = op(lvec[i], rvec[0]);
        } else if (rvec.size() == lvec.size()) {
            size_type size = rvec.size();
            vresult.resize(size);
            for (off_type i = 0; i < size; ++i)
                vresult[i] = op(lvec[i], rvec[i]);
        }
 
        return vresult;
    }
 
    Result
    total() const override
    {
        const VResult &vec = this->result();
        const VResult &lvec = l->result();
        const VResult &rvec = r->result();
        Result total = 0.0;
        Result lsum = 0.0;
        Result rsum = 0.0;
        Op op;
 
        assert(lvec.size() > 0 && rvec.size() > 0);
        assert(lvec.size() == rvec.size() ||
               lvec.size() == 1 || rvec.size() == 1);
 
        if (lvec.size() == rvec.size() && lvec.size() > 1) {
            for (off_type i = 0; i < size(); ++i) {
                lsum += lvec[i];
                rsum += rvec[i];
            }
            return op(lsum, rsum);
        }
 
        for (off_type i = 0; i < size(); ++i) {
            total += vec[i];
        }
 
        return total;
    }
 
    size_type
    size() const override
    {
        size_type ls = l->size();
        size_type rs = r->size();
        if (ls == 1) {
            return rs;
        } else if (rs == 1) {
            return ls;
        } else {
            assert(ls == rs && "Node vector sizes are not equal");
            return ls;
        }
    }
 
    std::string
    str() const override
    {
        return csprintf("(%s %s %s)", l->str(), OpString<Op>::str(), r->str());
    }
};
 
template <class Op>
class SumNode : public Node
{
  public:
    NodePtr l;
    mutable VResult vresult;
 
  public:
    SumNode(NodePtr &p) : l(p), vresult(1) {}
 
    const VResult &
    result() const
    {
        const VResult &lvec = l->result();
        size_type size = lvec.size();
        assert(size > 0);
 
        vresult[0] = 0.0;
 
        Op op;
        for (off_type i = 0; i < size; ++i)
            vresult[0] = op(vresult[0], lvec[i]);
 
        return vresult;
    }
 
    Result
    total() const
    {
        const VResult &lvec = l->result();
        size_type size = lvec.size();
        assert(size > 0);
 
        Result result = 0.0;
 
        Op op;
        for (off_type i = 0; i < size; ++i)
            result = op(result, lvec[i]);
 
        return result;
    }
 
    size_type size() const { return 1; }
 
    std::string
    str() const
    {
        return csprintf("total(%s)", l->str());
    }
};
 
 
//
// Visible Statistics Types
//
 
class Scalar : public ScalarBase<Scalar, StatStor>
{
  public:
    using ScalarBase<Scalar, StatStor>::operator=;
 
    Scalar(Group *parent = nullptr, const char *name = nullptr,
           const char *desc = nullptr)
        : ScalarBase<Scalar, StatStor>(parent, name, desc)
    {
    }
};
 
class Average : public ScalarBase<Average, AvgStor>
{
  public:
    using ScalarBase<Average, AvgStor>::operator=;
 
    Average(Group *parent = nullptr, const char *name = nullptr,
            const char *desc = nullptr)
        : ScalarBase<Average, AvgStor>(parent, name, desc)
    {
    }
};
 
class Value : public ValueBase<Value>
{
  public:
    Value(Group *parent = nullptr, const char *name = nullptr,
          const char *desc = nullptr)
        : ValueBase<Value>(parent, name, desc)
    {
    }
};
 
class Vector : public VectorBase<Vector, StatStor>
{
  public:
    Vector(Group *parent = nullptr, const char *name = nullptr,
           const char *desc = nullptr)
        : VectorBase<Vector, StatStor>(parent, name, desc)
    {
    }
};
 
class AverageVector : public VectorBase<AverageVector, AvgStor>
{
  public:
    AverageVector(Group *parent = nullptr, const char *name = nullptr,
                  const char *desc = nullptr)
        : VectorBase<AverageVector, AvgStor>(parent, name, desc)
    {
    }
};
 
class Vector2d : public Vector2dBase<Vector2d, StatStor>
{
  public:
    Vector2d(Group *parent = nullptr, const char *name = nullptr,
             const char *desc = nullptr)
        : Vector2dBase<Vector2d, StatStor>(parent, name, desc)
    {
    }
};
 
class Distribution : public DistBase<Distribution, DistStor>
{
  public:
    Distribution(Group *parent = nullptr, const char *name = nullptr,
                 const char *desc = nullptr)
        : DistBase<Distribution, DistStor>(parent, name, desc)
    {
    }
 
    Distribution &
    init(Counter min, Counter max, Counter bkt)
    {
        DistStor::Params *params = new DistStor::Params;
        params->min = min;
        params->max = max;
        params->bucket_size = bkt;
        // Division by zero is especially serious in an Aarch64 host,
        // where it gets rounded to allocate 32GiB RAM.
        assert(bkt > 0);
        params->buckets = (size_type)ceil((max - min + 1.0) / bkt);
        this->setParams(params);
        this->doInit();
        return this->self();
    }
};
 
class Histogram : public DistBase<Histogram, HistStor>
{
  public:
    Histogram(Group *parent = nullptr, const char *name = nullptr,
              const char *desc = nullptr)
        : DistBase<Histogram, HistStor>(parent, name, desc)
    {
    }
 
    Histogram &
    init(size_type size)
    {
        HistStor::Params *params = new HistStor::Params;
        params->buckets = size;
        this->setParams(params);
        this->doInit();
        return this->self();
    }
};
 
class StandardDeviation : public DistBase<StandardDeviation, SampleStor>
{
  public:
    StandardDeviation(Group *parent = nullptr, const char *name = nullptr,
                      const char *desc = nullptr)
        : DistBase<StandardDeviation, SampleStor>(parent, name, desc)
    {
        SampleStor::Params *params = new SampleStor::Params;
        this->doInit();
        this->setParams(params);
    }
};
 
class AverageDeviation : public DistBase<AverageDeviation, AvgSampleStor>
{
  public:
    AverageDeviation(Group *parent = nullptr, const char *name = nullptr,
                     const char *desc = nullptr)
        : DistBase<AverageDeviation, AvgSampleStor>(parent, name, desc)
    {
        AvgSampleStor::Params *params = new AvgSampleStor::Params;
        this->doInit();
        this->setParams(params);
    }
};
 
class VectorDistribution : public VectorDistBase<VectorDistribution, DistStor>
{
  public:
    VectorDistribution(Group *parent = nullptr, const char *name = nullptr,
                       const char *desc = nullptr)
        : VectorDistBase<VectorDistribution, DistStor>(parent, name, desc)
    {
    }
 
    VectorDistribution &
    init(size_type size, Counter min, Counter max, Counter bkt)
    {
        DistStor::Params *params = new DistStor::Params;
        params->min = min;
        params->max = max;
        params->bucket_size = bkt;
        params->buckets = (size_type)ceil((max - min + 1.0) / bkt);
        this->setParams(params);
        this->doInit(size);
        return this->self();
    }
};
 
class VectorStandardDeviation
    : public VectorDistBase<VectorStandardDeviation, SampleStor>
{
  public:
    VectorStandardDeviation(Group *parent = nullptr, const char *name = nullptr,
                            const char *desc = nullptr)
        : VectorDistBase<VectorStandardDeviation, SampleStor>(parent, name,
                                                              desc)
    {
    }
 
    VectorStandardDeviation &
    init(size_type size)
    {
        SampleStor::Params *params = new SampleStor::Params;
        this->doInit(size);
        this->setParams(params);
        return this->self();
    }
};
 
class VectorAverageDeviation
    : public VectorDistBase<VectorAverageDeviation, AvgSampleStor>
{
  public:
    VectorAverageDeviation(Group *parent = nullptr, const char *name = nullptr,
                           const char *desc = nullptr)
        : VectorDistBase<VectorAverageDeviation, AvgSampleStor>(parent, name,
                                                                desc)
    {
    }
 
    VectorAverageDeviation &
    init(size_type size)
    {
        AvgSampleStor::Params *params = new AvgSampleStor::Params;
        this->doInit(size);
        this->setParams(params);
        return this->self();
    }
};
 
template <class Stat>
class FormulaInfoProxy : public InfoProxy<Stat, FormulaInfo>
{
  protected:
    mutable VResult vec;
    mutable VCounter cvec;
 
  public:
    FormulaInfoProxy(Stat &stat) : InfoProxy<Stat, FormulaInfo>(stat) {}
 
    size_type size() const { return this->s.size(); }
 
    const VResult &
    result() const
    {
        this->s.result(vec);
        return vec;
    }
    Result total() const { return this->s.total(); }
    VCounter &value() const { return cvec; }
 
    std::string str() const { return this->s.str(); }
};
 
template <class Stat>
class SparseHistInfoProxy : public InfoProxy<Stat, SparseHistInfo>
{
  public:
    SparseHistInfoProxy(Stat &stat) : InfoProxy<Stat, SparseHistInfo>(stat) {}
};
 
template <class Derived, class Stor>
class SparseHistBase : public DataWrap<Derived, SparseHistInfoProxy>
{
  public:
    typedef SparseHistInfoProxy<Derived> Info;
    typedef Stor Storage;
    typedef typename Stor::Params Params;
 
  protected:
    char storage[sizeof(Storage)];
 
  protected:
    Storage *
    data()
    {
        return reinterpret_cast<Storage *>(storage);
    }
 
    const Storage *
    data() const
    {
        return reinterpret_cast<const Storage *>(storage);
    }
 
    void
    doInit()
    {
        new (storage) Storage(this->info());
        this->setInit();
    }
 
  public:
    SparseHistBase(Group *parent, const char *name, const char *desc)
        : DataWrap<Derived, SparseHistInfoProxy>(parent, name, desc)
    {
    }
 
    template <typename U>
    void sample(const U &v, int n = 1) { data()->sample(v, n); }
 
    size_type size() const { return data()->size(); }
    bool zero() const { return data()->zero(); }
 
    void
    prepare()
    {
        Info *info = this->info();
        data()->prepare(info, info->data);
    }
 
    void
    reset()
    {
        data()->reset(this->info());
    }
};
 
class SparseHistStor
{
  public:
    struct Params : public DistParams
    {
        Params() : DistParams(Hist) {}
    };
 
  private:
    Counter samples;
    MCounter cmap;
 
  public:
    SparseHistStor(Info *info)
    {
        reset(info);
    }
 
    void
    sample(Counter val, int number)
    {
        cmap[val] += number;
        samples += number;
    }
 
    size_type size() const { return cmap.size(); }
 
    bool
    zero() const
    {
        return samples == Counter();
    }
 
    void
    prepare(Info *info, SparseHistData &data)
    {
        MCounter::iterator it;
        data.cmap.clear();
        for (it = cmap.begin(); it != cmap.end(); it++) {
            data.cmap[(*it).first] = (*it).second;
        }
 
        data.samples = samples;
    }
 
    void
    reset(Info *info)
    {
        cmap.clear();
        samples = 0;
    }
};
 
class SparseHistogram : public SparseHistBase<SparseHistogram, SparseHistStor>
{
  public:
    SparseHistogram(Group *parent = nullptr, const char *name = nullptr,
                    const char *desc = nullptr)
        : SparseHistBase<SparseHistogram, SparseHistStor>(parent, name, desc)
    {
    }
 
    SparseHistogram &
    init(size_type size)
    {
        SparseHistStor::Params *params = new SparseHistStor::Params;
        this->setParams(params);
        this->doInit();
        return this->self();
    }
};
 
class Temp;
class Formula : public DataWrapVec<Formula, FormulaInfoProxy>
{
  protected:
    NodePtr root;
    friend class Temp;
 
  public:
    Formula(Group *parent = nullptr, const char *name = nullptr,
            const char *desc = nullptr);
 
    Formula(Group *parent, const char *name, const char *desc,
            const Temp &r);
 
    const Formula &operator=(const Temp &r);
 
    template<typename T>
    const Formula &operator=(const T &v)
    {
        *this = Temp(v);
        return *this;
    }
 
    const Formula &operator+=(Temp r);
 
    const Formula &operator/=(Temp r);
 
    void result(VResult &vec) const;
 
    Result total() const;
 
    size_type size() const;
 
    void prepare() { }
 
    void reset();
 
    bool zero() const;
 
    std::string str() const;
};
 
class FormulaNode : public Node
{
  private:
    const Formula &formula;
    mutable VResult vec;
 
  public:
    FormulaNode(const Formula &f) : formula(f) {}
 
    size_type size() const { return formula.size(); }
    const VResult &result() const { formula.result(vec); return vec; }
    Result total() const { return formula.total(); }
 
    std::string str() const { return formula.str(); }
};
 
class Temp
{
  protected:
    NodePtr node;
 
  public:
    Temp(const NodePtr &n) : node(n) { }
 
    Temp(NodePtr &&n) : node(std::move(n)) { }
 
    operator NodePtr&() { return node; }
 
    NodePtr getNodePtr() const { return node; }
 
  public:
    Temp(const Scalar &s)
        : node(new ScalarStatNode(s.info()))
    { }
 
    Temp(const Value &s)
        : node(new ScalarStatNode(s.info()))
    { }
 
    Temp(const Average &s)
        : node(new ScalarStatNode(s.info()))
    { }
 
    Temp(const Vector &s)
        : node(new VectorStatNode(s.info()))
    { }
 
    Temp(const AverageVector &s)
        : node(new VectorStatNode(s.info()))
    { }
 
    Temp(const Formula &f)
        : node(new FormulaNode(f))
    { }
 
    template <class Stat>
    Temp(const ScalarProxy<Stat> &p)
        : node(new ScalarProxyNode<Stat>(p))
    { }
 
    Temp(signed char value)
        : node(new ConstNode<signed char>(value))
    { }
 
    Temp(unsigned char value)
        : node(new ConstNode<unsigned char>(value))
    { }
 
    Temp(signed short value)
        : node(new ConstNode<signed short>(value))
    { }
 
    Temp(unsigned short value)
        : node(new ConstNode<unsigned short>(value))
    { }
 
    Temp(signed int value)
        : node(new ConstNode<signed int>(value))
    { }
 
    Temp(unsigned int value)
        : node(new ConstNode<unsigned int>(value))
    { }
 
    Temp(signed long value)
        : node(new ConstNode<signed long>(value))
    { }
 
    Temp(unsigned long value)
        : node(new ConstNode<unsigned long>(value))
    { }
 
    Temp(signed long long value)
        : node(new ConstNode<signed long long>(value))
    { }
 
    Temp(unsigned long long value)
        : node(new ConstNode<unsigned long long>(value))
    { }
 
    Temp(float value)
        : node(new ConstNode<float>(value))
    { }
 
    Temp(double value)
        : node(new ConstNode<double>(value))
    { }
};
 
 
inline Temp
operator+(Temp l, Temp r)
{
    return Temp(std::make_shared<BinaryNode<std::plus<Result> > >(l, r));
}
 
inline Temp
operator-(Temp l, Temp r)
{
    return Temp(std::make_shared<BinaryNode<std::minus<Result> > >(l, r));
}
 
inline Temp
operator*(Temp l, Temp r)
{
    return Temp(std::make_shared<BinaryNode<std::multiplies<Result> > >(l, r));
}
 
inline Temp
operator/(Temp l, Temp r)
{
    return Temp(std::make_shared<BinaryNode<std::divides<Result> > >(l, r));
}
 
inline Temp
operator-(Temp l)
{
    return Temp(std::make_shared<UnaryNode<std::negate<Result> > >(l));
}
 
template <typename T>
inline Temp
constant(T val)
{
    return Temp(std::make_shared<ConstNode<T> >(val));
}
 
template <typename T>
inline Temp
constantVector(T val)
{
    return Temp(std::make_shared<ConstVectorNode<T> >(val));
}
 
inline Temp
sum(Temp val)
{
    return Temp(std::make_shared<SumNode<std::plus<Result> > >(val));
}
 
void dump();
void reset();
void enable();
bool enabled();
const Info* resolve(const std::string &name);
 
typedef void (*Handler)();
 
void registerHandlers(Handler reset_handler, Handler dump_handler);
 
void registerResetCallback(const std::function<void()> &callback);
 
void registerDumpCallback(const std::function<void()> &callback);
 
void processResetQueue();
 
void processDumpQueue();
 
std::list<Info *> &statsList();
 
typedef std::map<const void *, Info *> MapType;
MapType &statsMap();
 
typedef std::map<std::string, Info *> NameMapType;
NameMapType &nameMap();
 
bool validateStatName(const std::string &name);
 
} // namespace Stats
 
void debugDumpStats();
 
#endif // __BASE_STATISTICS_HH__