eoTimer.h

/*
(c) Thales group, 2012

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation;
    version 2 of the License.

    This library 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
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
Contact: http://eodev.sourceforge.net

Authors:
    Benjamin Bouvier <benjamin.bouvier@gmail.com>
*/
# ifndef __EO_TIMER_H__
# define __EO_TIMER_H__

# include <sys/time.h> // time()
# include <sys/resource.h> // rusage()

# include <vector> // std::vector
# include <map> // std::map

# include "utils/eoParallel.h" // eo::parallel

# ifdef WITH_MPI
// For serialization purposes
# include <boost/serialization/access.hpp>
# include <boost/serialization/vector.hpp>
# include <boost/serialization/map.hpp>
# endif

class eoTimer
{
    public:

        eoTimer()
        {
            uuremainder = 0;
            usremainder = 0;
            restart();
        }

        void restart()
        {
            wc_start = time(NULL);
            getrusage( RUSAGE_SELF, &_start );
        }

        long int usertime()
        {
            struct rusage _now;
            getrusage( RUSAGE_SELF, &_now );

            long int result = _now.ru_utime.tv_sec - _start.ru_utime.tv_sec;
            long int remainder = _now.ru_utime.tv_usec - _start.ru_utime.tv_usec;
            if( remainder >= 0 )
            {
                uuremainder += remainder;
            } else
            {
                uuremainder += ( 1000000 - remainder );
                --result;
            }

            if( uuremainder >= 1000000 )
            {
                uuremainder -= 1000000;
                ++result;
            }
            return result;
        }

        long int systime()
        {
            struct rusage _now;
            getrusage( RUSAGE_SELF, &_now );

            long int result = _now.ru_stime.tv_sec - _start.ru_stime.tv_sec;
            long int remainder = _now.ru_stime.tv_usec - _start.ru_stime.tv_usec;
            if( remainder >= 0 )
            {
                usremainder += remainder;
            } else
            {
                usremainder += ( 1000000 - remainder );
                --result;
            }

            if( usremainder >= 1000000 )
            {
                usremainder -= 1000000;
                ++result;
            }
            return result;
        }

        double wallclock()
        {
            return std::difftime( std::time(NULL) , wc_start );
        }

    protected:
        // Structure used to measure user and system time.
        struct rusage _start;
        // Remainder (in milliseconds) for user time.
        long int uuremainder;
        // Remainder (in milliseconds) for system time.
        long int usremainder;
        // Structure used to measure wallclock time.
        time_t wc_start;
};

class eoTimerStat
{
    public:

        struct Stat
        {
            std::vector<long int> utime;
            std::vector<long int> stime;
            std::vector<double> wtime;
#ifdef WITH_MPI
            // Gives access to boost serialization
            friend class boost::serialization::access;

            template <class Archive>
                void serialize( Archive & ar, const unsigned int version )
                {
                    ar & utime & stime & wtime;
                    (void) version; // avoid compilation warning
                }
# endif
        };

#ifdef WITH_MPI
        // Gives access to boost serialization
        friend class boost::serialization::access;

        template <class Archive>
            void serialize( Archive & ar, const unsigned int version )
            {
                ar & _stats;
                (void) version; // avoid compilation warning
            }
# endif

        void start( const std::string & key )
        {
            if( eo::parallel.doMeasure() )
            {
                _timers[ key ].restart();
            }
        }

        void stop( const std::string& key )
        {
            if( eo::parallel.doMeasure() )
            {
                Stat & s = _stats[ key ];
                eoTimer & t = _timers[ key ];
                s.utime.push_back( t.usertime() );
                s.stime.push_back( t.systime() );
                s.wtime.push_back( t.wallclock() );
            }
        }

        std::map< std::string, Stat >& stats()
        {
            return _stats;
        }

    protected:
        // Statistics map: links a key (string) to a statistic.
        std::map< std::string, Stat > _stats;
        // Timers map: links a key to its timer.
        std::map< std::string, eoTimer > _timers;
};

# endif // __TIMER_H__