femtimer.hh

#ifndef DUNE_FEM_FEMTIMER_HH
#define DUNE_FEM_FEMTIMER_HH
 
#include <stack>
#include <vector>
#include <string>
#include <fstream>
#include <iomanip>
#include <limits>
 
#include <dune/common/exceptions.hh>
#include <dune/common/timer.hh>
 
#include <dune/fem/io/parameter.hh>
#include <dune/fem/solver/timeprovider.hh>
#include <dune/fem/storage/singleton.hh>
 
namespace Dune
{
 
  namespace Fem
  {
 
    // Timer
    // -----
 
    template< bool enable >
    struct Timer;
 
 
    template<>
    struct Timer< false >
    {
      typedef enum { max, sum } operation;
 
      static unsigned int addTo ( const std::string &name, int nr = 0 ) { return 0; }
      static void removeFrom ( unsigned int id ) {}
      static void removeAll () {}
 
      static void start ( int id, int nr = 0 ) {}
      static double stop ( int id, int nr = 0, operation op = sum ) { return -1; }
      static double stop ( int id, operation op ) { return -1; }
 
      static void reset() {}
      static void reset( int id ) {}
      static void reset( int id, int nr ) {}
 
      static void print ( std::ostream &out, int id ) {}
      static void print ( std::ostream &out, const std::string &msg = "" ) {}
 
      static void printFile ( const std::string &fileName, int step = 1 ) {}
      static void printFile ( const TimeProviderBase &tp,
                              const std::string &fileName, int step = 1 ) {}
    };
 
 
    template<>
    struct Timer< true >
    {
      typedef enum { max, sum } operation;
 
    private:
      struct TimerInfo
      {
        std::vector< double > startTimes, times;
        std::string name;
 
        TimerInfo ( const std::string &n, const unsigned int nr )
        : startTimes( nr ), times( nr ), name( n )
        {}
      };
 
    public:
      Timer ();
      ~Timer ();
 
    private:
      void push_time() { timesS_.push( timer_.elapsed() ); }
 
      double pop_time()
      {
        const double elapsed = timer_.elapsed() - timesS_.top();
        timesS_.pop();
        return elapsed;
      }
 
      unsigned int add ( const std::string &name, int nr );
      void remove ( unsigned int id );
      void remove ();
 
      void start_timer( int id, int nr )
      {
        timers_[ id ].startTimes[ nr ] = timer_.elapsed();
        assert( timers_[ id ].startTimes[ 0 ] >= double( 0 ) );
      }
 
      double stop_timer ( int id, int nr, operation op )
      {
        TimerInfo &info = timers_[ id ];
        assert( (info.startTimes[ nr ] >= double( 0 )) && (info.startTimes[ 0 ] >= double( 0 )) );
        double elapsed = timer_.elapsed() - info.startTimes[ nr ];
        info.startTimes[ nr ] = double( -1 );
        switch( op )
        {
        case sum:
          info.times[ nr ] += elapsed;
          break;
        case max:
          info.times[ nr ] = std::max( info.times[ nr ], elapsed );
          break;
        }
        return elapsed;
      }
 
      void reset_timer ( int id, int nr )
      {
        timers_[ id ].times[ nr ] = double( 0 );
        timers_[ id ].startTimes[ nr ] = double( -1 );
      }
 
      void reset_timer ( int id )
      {
        for( unsigned int i = 0; i < timers_[ id ].times.size(); ++i )
          reset_timer( id, i );
      }
 
      void reset_timer ()
      {
        for( unsigned int i = 0; i < timers_.size(); ++i )
          reset_timer( i );
      }
 
      void print_timer ( std::ostream &out, int id );
      void print_timer ( std::ostream &out, const std::string &msg );
 
      size_t inMS ( const double t )
      {
        return (size_t (t * 1e3));
      }
 
      size_t inProz ( const double p, double rel )
      {
        size_t ret = (size_t)((p / rel) * 100.);
        return std :: min( ret, size_t(100) );
      }
 
      void printToFile ();
      void printToFile ( const std::string &fileName, int step );
      void printToFile ( const TimeProviderBase &tp, const std::string &fileName, int step );
 
      friend class Dune::Fem::Singleton< Timer >;
 
      static Timer &instance ()
      {
        return Singleton< Timer > ::instance();
      }
 
    public:
      static void start () { instance().push_time(); }
 
      static double stop () { return instance().pop_time(); }
 
      static unsigned int addTo ( const std::string &name, int nr = 0 )
      {
        return instance().add(name,nr+1);
      }
 
      static void removeFrom ( unsigned int id ) { instance().remove( id ); }
 
      static void removeAll () { instance().remove(); }
 
      static void start ( int id, int nr = 0 ) { instance().start_timer( id, nr ); }
 
      static double stop ( int id, int nr = 0, operation op = sum )
      {
        return instance().stop_timer( id, nr, op );
      }
 
      static double stop ( int id, operation op )
      {
        return instance().stop_timer( id, 0, op );
      }
 
      static void reset () { instance().reset_timer(); }
 
      static void reset ( int id ) { instance().reset_timer( id ); }
 
      static void reset ( int id, int nr ) { instance().reset_timer( id, nr ); }
 
      static void print ( std::ostream &out, int id ) { instance().print_timer( out, id ); }
 
      static void print ( std::ostream &out, const std::string &msg = "" )
      {
        instance().print_timer(out,msg);
      }
 
      static void printFile ( const std::string &fileName, int step = 1 )
      {
        instance().printToFile(rankName(fileName, MPIManager::rank()),step);
      }
 
      static void printFile ( const TimeProviderBase &tp,
                              const std::string &fileName, int step = 1 )
      {
        instance().printToFile(tp,rankName(fileName, MPIManager::rank()),step);
      }
 
    private:
      static std::string rankName( const std::string &fileName, const int rank )
      {
        std::stringstream newfilename;
        newfilename << fileName << "." << rank ;
        return newfilename.str();
      }
 
      Dune::Timer timer_;
      std::stack< double > timesS_;
      std::vector< TimerInfo > timers_;
      std::ofstream output_;
      int stepCount_;
      bool changed_;
    };
 
    // this method is defined inline
    // because is uses MPI stuff which
    // does not work when compiled into the lib
    inline Timer< true >::~Timer ()
    {
      double totalTime = pop_time();
 
      if( output_.is_open() )
      {
        output_ << "#  ******** TOTAL RUNTIME: " << totalTime
                << "   ******** " << std::endl;
        output_.close();
      }
 
      const MPIManager::Communication &comm = MPIManager::comm();
      if( comm.rank() == 0 )
      {
        double *totalTimes = new double[ comm.size() ];
        comm.gather( &totalTime, totalTimes, 1, 0 );
        double avgTime = 0.0;
        double minTime = std::numeric_limits< double >::max();
        double maxTime = std::numeric_limits< double >::min();
        for( int i = 0; i < comm.size(); ++i )
        {
          avgTime += totalTimes[ i ];
          minTime = std::min( minTime, totalTimes[ i ] );
          maxTime = std::max( maxTime, totalTimes[ i ] );
        }
        avgTime /= comm.size();
        delete[] totalTimes;
 
        std::cerr << "#  ******** TOTAL RUNTIME: average = " << avgTime
                  << ", minimum = " << minTime << ", maximum = " << maxTime
                  << "   ******** " << std::endl;
      }
      else
        comm.gather( &totalTime, (double *)0, 1, 0 );
    }
 
  } // namespace Fem
 
 
 
#ifdef FEMTIMER
    typedef Fem::Timer< true > FemTimer;
#else
    typedef Fem::Timer< false > FemTimer;
#endif
 
 
 
#define TIMEDEXECUTION(command) \
    (femTimer.start(),command,femTimer.stop())
  class ExecutionTimer {
    public:
    ExecutionTimer() : total_(0) {
    }
    void start() {
      start_=time_.elapsed();
    }
    void end() {
      total_=start_-time_.elapsed();
    }
    double read() {
      return total_;
    }
    void reset() {
      total_=0;
    }
    double total_;
    double start_;
    Timer time_;
  };
 
} // namespace Dune
 
#endif // #ifndef DUNE_FEM_FEMTIMER_HH