Search:

SENF Extensible Network Framework

• Home
• Download
• Wiki
• BerliOS
• ChangeLog
• Browse SVN
• Bug Tracker

Statistics.hh

Go to the documentation of this file.

// $Id: Statistics.hh 1781 2011-04-11 12:10:19Z tho $
//
// Copyright (C) 2008
// Fraunhofer (FOKUS)
// Competence Center NETwork research (NET), St. Augustin, GERMANY
//     Stefan Bund <g0dil@berlios.de>
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the
// Free Software Foundation, Inc.,
// 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#ifndef HH_SENF_Utils_Statistics_
#define HH_SENF_Utils_Statistics_ 1

// Custom includes
#include <map>
#include <vector>
#include <deque>
#include <boost/iterator/transform_iterator.hpp>
#include <boost/range/iterator_range.hpp>
#include <boost/utility.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/signals.hpp>
#include <senf/Utils/Logger/Logger.hh>
#include <senf/Utils/Console/ScopedDirectory.hh>
#include "StatisticAccumulator.hh"
#include "Exception.hh"

//#include "Statistics.mpp"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {

    class Collector;
    class Statistics;

    class StatisticsBase
    {
        typedef std::map<unsigned, Collector> Children;

        struct Transform {
            typedef Children::value_type & first_argument_type;
            typedef Collector & result_type;
            result_type operator()(first_argument_type i) const;
        };

        typedef boost::transform_iterator<Transform,Children::iterator> ValueIterator;

        struct OutputEntry;

    public:
        //-////////////////////////////////////////////////////////////////////////
        // Types

        typedef boost::iterator_range<ValueIterator> CollectorRange;

        template <class Owner>
        class OutputProxy
        {
        public:
            template <class Target> Owner & connect(Target & target,
                                                    std::string label="") const;
            template <class PTarget> Owner & connect(std::auto_ptr<PTarget> target,
                                                     std::string label="") const;
            Owner & noconnect() const;  
            senf::console::ScopedDirectory<> & dir() const;

#ifdef DOXYGEN
        private:
#endif
            OutputProxy(Owner * owner, OutputEntry * entry);
            template <class OtherOwner>
            OutputProxy(Owner * owner, OutputProxy<OtherOwner> const & other);

        private:
            Owner * owner_;
            OutputEntry * entry_;

            template <class OtherOwner> friend class OutputProxy;
        };

        //-////////////////////////////////////////////////////////////////////////
        //\{

        float min() const;              
        float avg() const;              
        float max() const;              
        float dev() const;              

        virtual unsigned rank() const;  

        //\}
        //-////////////////////////////////////////////////////////////////////////
        //\{

        Collector & operator[](unsigned rank);

        Collector const & operator[](unsigned rank) const;

        CollectorRange collectors();    

        Collector & collect(unsigned rank); 

        Statistics & base();            

        std::string path() const;       

        //\}
        //-////////////////////////////////////////////////////////////////////////

        OutputProxy<StatisticsBase> output(unsigned n = 1u);

        //\}
        //-////////////////////////////////////////////////////////////////////////
        // Exceptions

        struct InvalidRankException : public senf::Exception
        { InvalidRankException() : senf::Exception("Invalid rank value") {} };

        struct DuplicateRankException : public senf::Exception
        { DuplicateRankException() : senf::Exception("Duplicate rank value") {} };

        void consoleList(unsigned level, std::ostream & os) const;

    protected:
        StatisticsBase();
        virtual ~StatisticsBase();
        void enter(unsigned n, float min, float avg, float max, float dev);

    private:
        virtual Statistics & v_base() = 0;
        virtual std::string v_path() const = 0;

        void generateOutput();

        float min_;
        float avg_;
        float max_;
        float dev_;
        Children children_;

        struct QueueEntry {
            float min;
            float avg;
            float max;
            float dev;
            QueueEntry() : min(), avg(), max(), dev() {}
            QueueEntry(float min_, float avg_, float max_, float dev_)
                : min(min_), avg(avg_), max(max_), dev(dev_) {}
        };
        typedef std::deque<QueueEntry> Queue;
        Queue queue_;

        struct OutputEntry {
            struct TargetBase
            {
                explicit TargetBase(std::string const & label_) : label (label_) {}
                virtual ~TargetBase() {};
                std::string label;
            };

            template <class PTarget>
            struct Target : public TargetBase
            {
                boost::scoped_ptr<PTarget> target_;
                Target(std::auto_ptr<PTarget> target, std::string const & label)
                    : TargetBase (label), target_ (target.release()) {}
                explicit Target(std::string const & label)
                    : TargetBase (label), target_ (0) {}
            };

            OutputEntry();
            explicit OutputEntry(unsigned n_);
            OutputEntry(const OutputEntry& other);
            OutputEntry& operator=(const OutputEntry& other);

            void initDir();
            void consoleList(std::ostream & os);

            unsigned n;
            float min;
            float avg;
            float max;
            float dev;

            boost::signal<void(float,float,float,float)> signal;
            boost::ptr_vector<TargetBase> targets_;

            senf::console::ScopedDirectory<> dir;
        };
        typedef std::map<unsigned, OutputEntry> OutputMap;
        OutputMap outputs_;
        unsigned maxQueueLen_;
    };

    class Statistics
        : public StatisticsBase, boost::noncopyable
    {
    public:
#ifndef SENF_DISABLE_CONSOLE
        console::ScopedDirectory<Statistics> dir;
#endif

        Statistics();

        void operator()(unsigned n, float min, float avg, float max, float dev);

        void operator()(float min, float avg, float max, float dev=0.0f);

        void operator()(float value, float dev=0.0f);

        void operator()(StatisticsData const & data);

        template <class Value>
        void operator()(unsigned n, StatisticAccumulator<Value> & sa);

        StatisticsBase::OutputProxy<Statistics> output(unsigned n = 1u);

        void consoleList(std::ostream & os);
        void consoleCollect(std::vector<unsigned> & ranks);
        boost::shared_ptr<senf::console::DirectoryNode> consoleOutput(
            std::vector<unsigned> & ranks, unsigned window);

    private:
        Statistics & v_base();
        std::string v_path() const;
    };

    class Collector : public StatisticsBase
    {
    public:
        virtual unsigned rank() const;

        StatisticsBase::OutputProxy<Collector> output(unsigned n = 1u);

    private:
        Collector(StatisticsBase * owner, unsigned rank);
        void enter(unsigned n, float min, float avg, float max, float dev);
        Statistics & v_base();
        std::string v_path() const;

        unsigned rank_;
        unsigned i_;
        float accMin_;
        float accSum_;
        float accSumSq_;
        float accMax_;
        StatisticsBase * owner_;

        friend class StatisticsBase;
    };

}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#include "Statistics.cci"
//#include "Statistics.ct"
#include "Statistics.cti"
#endif


// Local Variables:
// mode: c++
// fill-column: 100
// comment-column: 40
// c-file-style: "senf"
// indent-tabs-mode: nil
// ispell-local-dictionary: "american"
// compile-command: "scons -u test"
// End:

---

Contact: senf-dev@lists.berlios.de | © 2006-2010 Fraunhofer Institute for Open Communication Systems, Network Research