TPZTimer.h

Go to the documentation of this file.

#ifndef TPZTIMER_H
#define TPZTIMER_H

#include <string>
#include <vector>
#include <iostream>

#include <time.h>

struct PZResourceUsage
{
                int waitstatus;

                clock_t start;
                clock_t elapsed;
};   // Change from the original "RESUSE".


//--| TPZTimer |----------------------------------------------------------------

class TPZTimer
{
public:
                /* @brief Empty constructor */
                TPZTimer();
                
                TPZTimer( std::string pn );
                
                ~TPZTimer();
                
                std::string& processName();
                
                const std::string& processName() const;
                
                void start();
                
                void stop();
                
                void reset();
                
                double seconds() const;
                
                friend std::ostream& operator<<( std::ostream& Out, const TPZTimer& t );
                
private:
                PZResourceUsage resources;
                
                double AccumSec;
                
                std::string ProcessName;
};

//--| TPZMultiTimer |-----------------------------------------------------------

class TPZMultiTimer
{
public:
                TPZMultiTimer( int nT );
                
                ~TPZMultiTimer();
                
                int nTimers() const;
                
                TPZTimer& getTimer( int i );
                
                const TPZTimer& getTimer( int i ) const;
                
                std::string& processName( int i );
                
                const std::string& processName( int i ) const;
                
                void start( int i );
                
                void start();
                
                void stop( int i );
                
                void stop();
                
                void reset( int i );
                
                void reset();
                
                double seconds( int i ) const;
                
                friend std::ostream& operator<<( std::ostream& Out, const TPZMultiTimer& t );
                
private:
                std::vector< TPZTimer > timers;
};

//--| IMPLEMENTATION :: TPZTimer |----------------------------------------------

// Empty constructor.
inline TPZTimer::TPZTimer() : AccumSec( 0.0 ), ProcessName( "" ) {}

// Default constructor.
inline TPZTimer::TPZTimer( std::string pn ) : AccumSec( 0.0 ), ProcessName( pn ) {}

// Destructor.
inline TPZTimer::~TPZTimer() {}

// Gets the process name (for reporting purposes).
inline std::string& TPZTimer::processName()
{
                return ProcessName;
}

// Gets the process name (for reporting purposes).
inline const std::string& TPZTimer::processName() const
{
                return ProcessName;
}

// Resets the timer.
inline void TPZTimer::reset()
{
                AccumSec = 0.0;
}

// Returns the total accumulated time in seconds.
inline double TPZTimer::seconds() const
{
                return AccumSec;
}

//--| IMPLEMENTATION :: TPZMultiTimer |-----------------------------------------

// Default constructor.
inline TPZMultiTimer::TPZMultiTimer( int nT ) : timers()
{
                timers = std::vector< TPZTimer >( nT );
}

// Destructor.
inline TPZMultiTimer::~TPZMultiTimer()
{
                // Nothing to do here!
}

// Number of active timers.
inline int TPZMultiTimer::nTimers() const
{
                return timers.size();
}

// Returns a specific timer.
inline TPZTimer& TPZMultiTimer::getTimer( int i )
{
                return timers[ i ];
}

// Returns a specific timer.
inline const TPZTimer& TPZMultiTimer::getTimer( int i ) const
{
                return timers[ i ];
}

// Gets the process name (for reporting purposes).
inline std::string& TPZMultiTimer::processName( int i )
{
                return timers[ i ].processName();
}

// Gets the process name (for reporting purposes).
inline const std::string& TPZMultiTimer::processName( int i ) const
{
                return timers[ i ].processName();
}

// Turns the timer on.
inline void TPZMultiTimer::start( int i )
{
                timers[ i ].start();
}

// Turns the timer on.
inline void TPZMultiTimer::start()
{
                for( unsigned int ii = 0; ii < timers.size(); ii++ )
                {
                                timers[ ii ].start();
                }
}

// Turns the timer off, and computes the elapsed time.
inline void TPZMultiTimer::stop( int i )
{
                timers[ i ].stop();
}

// Turns the timer off, and computes the elapsed time.
inline void TPZMultiTimer::stop()
{
                for( unsigned int ii = 0; ii < timers.size(); ii++ )
                {
                                timers[ ii ].stop();
                }
}

// Zeroes the timer.
inline void TPZMultiTimer::reset( int i )
{
                timers[ i ].reset();
}

// Zeroes the timer.
inline void TPZMultiTimer::reset()
{
                for( unsigned int ii = 0; ii < timers.size(); ii++ )
                {
                                timers[ ii ].reset();
                }
}

// Returns the elapsed time in seconds.
inline double TPZMultiTimer::seconds( int i ) const
{
                return timers[ i ].seconds();
}

#endif // TPZTIMER_H