Statistics.hh

Go to the documentation of this file.

//
// Copyright (c) 2020 Fraunhofer Institute for Applied Information Technology (FIT)
//                    Network Research Group (NET)
//                    Schloss Birlinghoven, 53754 Sankt Augustin, GERMANY
//                    Contact: support@wiback.org
//
// This file is part of the SENF code tree.
// It is licensed under the 3-clause BSD License (aka New BSD License).
// See LICENSE.txt in the top level directory for details or visit
// https://opensource.org/licenses/BSD-3-Clause
//


#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/noncopyable.hpp>
#include <boost/ptr_container/ptr_vector.hpp>
#include <boost/signals2.hpp>
#include <senf/Utils/Console/ScopedDirectory.hh>
#include <senf/Utils/Cpp11Support/smart_ptr.hh>
#include "StatisticAccumulator.hh"
#include "Exception.hh"

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

namespace senf {

    class Collector;
    class Statistics;

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

        // why we can't use ::__gnu_cxx::select2nd instead?!?!
        struct Transform {
            typedef Children::value_type & first_argument_type;
            typedef Collector & result_type;
            result_type operator()(first_argument_type i) const;
        };
        struct ConstTransform {
            typedef Children::value_type const & first_argument_type;
            typedef Collector const & result_type;
            result_type operator()(first_argument_type i) const;
        };

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

        struct OutputEntry;

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

        typedef boost::iterator_range<ValueIterator> CollectorRange;
        typedef boost::iterator_range<const_ValueIterator> const_CollectorRange;

        template <class Owner>
        class OutputProxy
        {
        public:
            template <class Target> Owner & connect(Target & target,
                                                    std::string label="") const;
            template <class PTarget> Owner & connect(std::unique_ptr<PTarget> target,
                                                     std::string label="") const;
            Owner & noconnect() const;  
            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;
        };

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

        unsigned cnt () const;          
        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();    

        const_CollectorRange collectors() const;

        Collector & collect(unsigned rank); 

        Statistics const & base() const;
        Statistics & base();            

        std::string path() const;       

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

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

        //\}
        StatisticsData data() const;    

        //-////////////////////////////////////////////////////////////////////////
        // 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, unsigned cnt, float min, float avg, float max, float dev);

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

        void generateOutput();

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

        struct QueueEntry {
            unsigned cnt;
            float min;
            float avg;
            float max;
            float dev;
            QueueEntry() : cnt(), min(), avg(), max(), dev() {}
            QueueEntry(unsigned cnt_, float min_, float avg_, float max_, float dev_)
                : cnt(cnt_), 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::unique_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;
            unsigned cnt;
            float min;
            float avg;
            float max;
            float dev;

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

            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<> dir;
#endif

        Statistics();

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

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

        void operator()(unsigned cnt, 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);

    private:
        void consoleCollect(std::vector<unsigned> & ranks);
        void consoleList(std::ostream & os) const;
        boost::shared_ptr<console::DirectoryNode> consoleOutput(
                std::vector<unsigned> & ranks, unsigned window);
        Statistics & v_base();
        std::string v_path() const;
    };

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

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

        bool updated() const;

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

        unsigned rank_;
        unsigned i_;
        unsigned l_;
        unsigned accCnt_;
        float accMin_;
        float accSum_;
        float accSumSq_;
        float accMax_;
        StatisticsBase * owner_;
        bool updated_;  // true indicates that StatisticsBase::enter() was called

        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: