timer.h

Go to the documentation of this file.

/* -*- mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */

#ifndef __TIMER_H
#define __TIMER_H

#include <iostream>
#include <string>
//#include "MtcpCheckpointManager.h"

class BaseTimer { 
    public:
        enum { 
                MSPSEC = 1000000  
        };

        // todo: welche Konsequenzen hat es, _start_t mit 0 zu initialisieren?
        inline BaseTimer():_start_t(0)  { clear(); };

        inline void clear() { _t = 0;  }

        inline double time() const { return _t; }

        static long seed();

        std::ostream &print (std::ostream &) const;
       
                // -- Some arithmetic operators to compute cumulative time :
                BaseTimer& operator = (const BaseTimer & T) ;
                const BaseTimer operator - (const BaseTimer & T)  const;
                const BaseTimer operator - () ;
                const BaseTimer operator +  (const BaseTimer & T)  const;
                BaseTimer& operator += (const BaseTimer & T) { return *this = *this + T; };
                BaseTimer& operator -= (const BaseTimer & T) { return *this = *this - T; };
    public:
        double _start_t;  
        double _t;        

};

inline std::ostream &operator << (std::ostream &o, const BaseTimer &BT)
        { return BT.print(o); }

class RealTimer : public BaseTimer {
    public:
        inline RealTimer (const BaseTimer &BT) : BaseTimer (BT) {  };
        inline RealTimer () {  };
        void start ();
        void stop ();
};


class UserTimer : public BaseTimer {
    public:
        inline UserTimer (const BaseTimer &BT) : BaseTimer (BT) {};
        inline UserTimer () { };
        void start ();
        void stop ();
};


class SysTimer : public BaseTimer {
    public:
        inline SysTimer (const BaseTimer &BT): BaseTimer (BT) {};
        inline SysTimer () { };
        void start ();
        void stop ();
};

class Timer {

        friend class MtcpCheckpointManager;
    public :

        inline Timer () { clear(); };


        void clear(); 

        void start ();

        void stop ();

        void pauseTimer ();

        void continueTimer ();

        double usertime () const { return ut.time(); }

        double systime () const { return st.time(); }

        double realtime () const { return rt.time(); }

        // retourne une petite graine
        // long seed() const { return RealTimer::seed(); }
                // Some arithmetic operators to compute cumulative time :
                Timer& operator = (const Timer & T) ;
                const Timer operator - (const Timer & T)  const;
                const Timer operator - () ;
                const Timer operator + (const Timer & T)  const;
                Timer& operator += (const Timer & T) { return *this = *this + T; };
                Timer& operator -= (const Timer & T) { return *this = *this - T; };
        // -- methods :
        std::ostream &print (std::ostream &) const;

        size_t count() const {return _count;}

    private:
        size_t _count; // how many 

        RealTimer rt;
        UserTimer ut;
        SysTimer  st;

                bool b_IsRunning; 
                bool b_Paused;
};

// inline std::ostream &operator << (std::ostream &o, const Timer &T)
//      { return T.print (o); }

inline std::ostream &operator << (std::ostream &o, const Timer &T)
{ 
        double ut = T.usertime();
        if (ut < 0.0000000001) ut = 0;
        return o << T.realtime() << "s (" << ut << " cpu) [" << T.count() << "]"; }
 



inline void outputTimerInfoEx(std::ostream & os, Timer &tim, std::string ostring)
{       
        os << ostring << " : " << tim.usertime() << " sec." << std::endl;
}




//#include "timer.C"

#endif