CpuTimer.h

# ifndef Conjecture_CpuTimer_h
# define Conjecture_CpuTimer_h Conjecture_CpuTimer_h

// Insert SVN header substitution variable here
// Class Champion: Unassigned

# include "Root.h"  // parent

# include <sys/time.h>
# include <sys/resource.h>
# include <iomanip>  // setw

namespace Conjecture {

    // FUTURE FIX: Are these macros necessary?
# define TIME_USAGE(usage) \
        struct rusage usage; \
        if ( getrusage(RUSAGE_SELF,&usage) != 0 ) { cerr << "ERROR: getrusage failed!" << endl; exit(1); }
    
// end_usage   must be a 'struct rusage' variable
// start_usage must be a 'struct rusage' variable
// time must be a 'unsigned' variable
# define TIME_USAGE_DIFF(end_usage, start_usage, time) \
                time = \
                    ((now.ru_utime.tv_sec - start.ru_utime.tv_sec) * 1000000) + \
                    (now.ru_utime.tv_usec - start.ru_utime.tv_usec) + \
                    ((now.ru_stime.tv_sec - start.ru_stime.tv_sec) * 1000000) + \
                    (now.ru_stime.tv_usec - start.ru_stime.tv_usec); 
    
    // iters must be an unsigned number 
# define TIME_START_ITERATION(iters) { \
                 TIME_USAGE(start); \
                 for ( unsigned __i = 0; __i < iters; ++__i )
 
# define TIME_END_ITERATION(tdiff) \
               TIME_USAGE(now); \
               TIME_USAGE_DIFF(now, start, tdiff); \
            }

    
    class CpuTimer : public Root {
      public:
        // Types

        // Constructors/Destructors
        CpuTimer();

        // Accessors
        inline const bool &          running() const { return this->_running; }
        inline const struct rusage & reading() const { return this->_reading; }
        inline const struct rusage & start()   const { return this->_start; }
        
        // Input/Output
        
        // Interface

        void start();

        void stop();

        inline unsigned time()            const {return  read() / 1000000; }

        inline unsigned timeUser()        const { return readUser() / 1000000; }

        inline unsigned timeSystem()      const { return readSystem() / 1000000; }

        inline unsigned millitime()       const { return read() / 1000; }

        inline unsigned millitimeUser()   const { return readUser() / 1000; }

        inline unsigned millitimeSystem() const { return readSystem() / 1000; }

        inline unsigned microtime()       const { return read() ; }

        inline unsigned microtimeUser()   const { return readUser() ; }

        inline unsigned microtimeSystem() const { return readSystem() ; }

        void print(ostream & os = cout) const;

        void printSummary(ostream & os = cout) const;
        void printMilliSummary(ostream & os = cout) const;
        void printMicroSummary(ostream & os = cout) const;

        static void test(int argc = 0, const char* argv[] = NULL);
    
      protected:
        // Accessors
        inline void            runningIs(const bool & running) { this->_running = running; }
        inline void            readingIs(const struct rusage & reading) { this->_reading = reading; }
        inline void            startIs(const struct rusage & start) { this->_start = start; }
        
        // Methods 
        
      private: 
        // Accessors
        inline bool &          runningRef() { return this->_running; }
        inline struct rusage & readingRef() { return this->_reading; }
        inline struct rusage & startRef() { return this->_start; }
        
        // Methods 

        inline void getInfo( struct rusage & info ) const {
            if ( getrusage(RUSAGE_SELF,&info) != 0 ) {
                cerr << "ERROR: getrusage failed!" << endl;
                // Throw an exception instead of crashing!
                exit(1);
            }
        }

        unsigned long read() const;
        unsigned long readUser() const;
        unsigned long readSystem() const;
        
        // State
        bool            _running;
        struct rusage   _reading;
        struct rusage   _start;
    };
}

# endif // Conjecture_CpuTimer_h

---