src/lib-gmapkernel/chrono.hh

Go to the documentation of this file.

/*
 * lib-gmapkernel : Un noyau de 3-G-cartes et des opérations.
 * Copyright (C) 2004, Moka Team, Université de Poitiers, Laboratoire SIC
 *               http://www.sic.sp2mi.univ-poitiers.fr/
 * Copyright (C) 2009, Guillaume Damiand, CNRS, LIRIS,
 *               guillaume.damiand@liris.cnrs.fr, http://liris.cnrs.fr/
 *
 * This file is part of lib-gmapkernel
 *
 * This program 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, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 program.  If not, see <http://www.gnu.org/licenses/>.
 */

//******************************************************************************
#ifndef CHRONO_HH
#define CHRONO_HH
//******************************************************************************
//#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <string>
#include <sstream>
#include <iomanip>
#include <iostream>
//******************************************************************************
/* Classe pour chronométrer. Le chrono est initialisé à 0 et
 * additionne les temps entre des start() et des stop(). reset()
 * permet de remettre le chrono à zéro.
 * La méthode displayRealTime permet de choisir si l'affichage du temps
 * est en mode réel (i.e. en 10-6 secondes) ou utilisateur (affichage
 * dépendant du temps passé s, ms ou us). Par défaut utilisateur.
 * La méthode setMode permet de choisir le mode de chronométrage :
 * REEL_MODE : horloge temps réel (temps réel écoulé depuis le start)
 * PUS_MODE  : horloge processus (temps consommé par le processus)
 * REEL_AND_PUS_MODE : les 2 en même temps, mode par défaut.
 */
//******************************************************************************
typedef enum { REEL_MODE, PUS_MODE, REEL_AND_PUS_MODE } TModeChrono;
//******************************************************************************
class CChrono
{
public:
  
  CChrono ( TModeChrono AMode=REEL_AND_PUS_MODE, bool ADisplayReal=true);

  CChrono ( const CChrono& AChrono );

  CChrono& operator=( const CChrono& AChrono );
  
  CChrono& operator+=( const CChrono& AChrono );
  
  CChrono operator+( const CChrono& AChrono ) const;
  
  CChrono& operator-=( const CChrono& AChrono );

  CChrono operator-( const CChrono& AChrono ) const;

  void start ();

  void stop ();

  void reset();

  std::string getTime ( const std::string& AMessage );

  void display ( const std::string& AMessage );

  void displayRealTime( bool AValue );

  void setMode( TModeChrono AValue );

private:
  std::string convertTimeval( const struct timeval& ATimeval ) const;  
  
  void pickTimeReel( struct timeval& ATimeval ) const;
  
  void pickTimePus( struct rusage& ARusage ) const;
  
  struct rusage FBeforePus; 
  struct rusage FAfterPus;  
  struct rusage FTotalPus;  

  
  struct timeval FBeforeReel; 
  struct timeval FAfterReel; 
  struct timeval FTotalReel; 
  
  
  bool FDisplayReal; 

  TModeChrono FMode; 
  bool FRun; 
};
//******************************************************************************
//* Ici le code, tout est en inline. *******************************************
//******************************************************************************
inline
CChrono::CChrono( TModeChrono AMode, bool ADisplayReal ) :
  FDisplayReal(ADisplayReal),
  FMode(AMode),
  FRun(false)
{
  FTotalPus.ru_utime.tv_sec  = 0; FTotalPus.ru_utime.tv_usec = 0;

  FTotalPus.ru_stime.tv_sec  = 0; FTotalPus.ru_stime.tv_usec = 0;
 
  FTotalReel.tv_sec = 0; FTotalReel.tv_usec = 0;  
}
//------------------------------------------------------------------------------
inline
CChrono::CChrono( const CChrono& AChrono ) :
  FBeforePus  (AChrono.FBeforePus),
  FAfterPus   (AChrono.FAfterPus),
  FTotalPus   (AChrono.FTotalPus),
  FBeforeReel (AChrono.FBeforeReel),
  FAfterReel  (AChrono.FAfterReel),
  FTotalReel  (AChrono.FTotalReel),
  FDisplayReal(AChrono.FDisplayReal),
  FMode       (AChrono.FMode),
  FRun        (AChrono.FRun)
{}
//******************************************************************************
inline
void addTimeval( struct timeval& ATimeval, const struct timeval& ATimeval2)
{
  ATimeval.tv_sec  += ATimeval2.tv_sec;
  ATimeval.tv_usec += ATimeval2.tv_usec;
  if ( ATimeval.tv_usec >= 10000000 )
    {
      ++ATimeval.tv_sec;
      ATimeval.tv_usec -= 1000000;
    }
}
//------------------------------------------------------------------------------
inline
void substractTimeval( struct timeval& ATimeval, const struct timeval& ATimeval2)
{
  ATimeval.tv_sec  -= ATimeval2.tv_sec;
  ATimeval.tv_usec -= ATimeval2.tv_usec;
  if ( ATimeval.tv_usec < 0 )
    {
      --ATimeval.tv_sec;
      ATimeval.tv_usec += 1000000;
    }
}
//------------------------------------------------------------------------------
inline
void CChrono::pickTimeReel( struct timeval& ATimeval ) const
{
  gettimeofday(&ATimeval,NULL);
}
//------------------------------------------------------------------------------
inline
void  CChrono::pickTimePus( struct rusage& ARusage ) const
{
  getrusage(RUSAGE_SELF, &ARusage);
}
//******************************************************************************
inline
CChrono& CChrono::operator=( const CChrono& AChrono )
{
  FBeforePus   = AChrono.FBeforePus;
  FAfterPus    = AChrono.FAfterPus;
  FTotalPus    = AChrono.FTotalPus;
  
  FBeforeReel  = AChrono.FBeforeReel;
  FAfterReel   = AChrono.FAfterReel;
  FTotalReel   = AChrono.FTotalReel;
  
  FDisplayReal = AChrono.FDisplayReal;
  FMode        = AChrono.FMode;
  FRun         = AChrono.FRun;

  return *this;
}
//------------------------------------------------------------------------------
inline
CChrono& CChrono::operator+=( const CChrono& AChrono )
{
  addTimeval( FTotalPus.ru_utime, AChrono.FTotalPus.ru_utime );
  addTimeval( FTotalPus.ru_stime, AChrono.FTotalPus.ru_stime );
  addTimeval( FTotalReel, AChrono.FTotalReel );

  return *this;
}
//------------------------------------------------------------------------------
inline
CChrono CChrono::operator+( const CChrono& AChrono ) const
{
  CChrono res(*this);
  res += AChrono;

  return res;
}
//******************************************************************************
inline
CChrono& CChrono::operator-=( const CChrono& AChrono )
{
  substractTimeval( FTotalPus.ru_utime, AChrono.FTotalPus.ru_utime );
  substractTimeval( FTotalPus.ru_stime, AChrono.FTotalPus.ru_stime );
  substractTimeval( FTotalReel, AChrono.FTotalReel );

  return *this;
}
//------------------------------------------------------------------------------
inline
CChrono CChrono::operator-( const CChrono& AChrono ) const
{
  CChrono res(*this);
  res -= AChrono;

  return res;
}
//******************************************************************************
inline
void CChrono::start ()
{
  if ( !FRun )
    {
      pickTimePus ( FBeforePus );
      pickTimeReel( FBeforeReel );
      FRun = true;
    }
}
//------------------------------------------------------------------------------
inline
void CChrono::stop ()
{
  if ( FRun )
    {
      // Récupération de l'horloge courante.
      pickTimeReel( FAfterReel );
      pickTimePus ( FAfterPus );

      // Calcul de FAfter = FAfter-FBefore
      substractTimeval( FAfterPus.ru_utime, FBeforePus.ru_utime );
      substractTimeval( FAfterPus.ru_stime, FBeforePus.ru_stime );
      substractTimeval( FAfterReel, FBeforeReel );
      
      // Ajout dans FTotal
      addTimeval( FTotalPus.ru_utime, FAfterPus.ru_utime );
      addTimeval( FTotalPus.ru_stime, FAfterPus.ru_stime );
      addTimeval( FTotalReel, FAfterReel );
      
      FRun = false;
    }  
}
//------------------------------------------------------------------------------
inline
void CChrono::reset()
{
  FTotalPus.ru_utime.tv_sec  = 0; FTotalPus.ru_utime.tv_usec = 0;

  FTotalPus.ru_stime.tv_sec  = 0; FTotalPus.ru_stime.tv_usec = 0;
  
  FTotalReel.tv_sec = 0; FTotalReel.tv_usec = 0;  

  FRun = false;
}
//******************************************************************************
inline
void CChrono::setMode( TModeChrono AMode )
{
  FMode = AMode;
  if ( FRun )
    {
      stop();
      reset();
    }
}
//------------------------------------------------------------------------------
inline
void CChrono::displayRealTime( bool AValue )
{ FDisplayReal = AValue; }
//******************************************************************************
inline
std::string CChrono::convertTimeval ( const struct timeval & ATimeval ) const
{
  std::ostringstream res;
  
  if ( FDisplayReal )
    { // Mode réel.
          res<<ATimeval.tv_sec<<'.'
             <<std::setw(6)<<std::setfill('0')<<ATimeval.tv_usec<<" s";
    }
  else
    {
      // Mode utilisateur cad on prend l'unité appropriée.
      if ( ATimeval.tv_sec!=0 || ATimeval.tv_usec>=150000 )
        res<<ATimeval.tv_sec<<'.'
           <<std::setw(2)<<std::setfill('0')
           <<(int)(ATimeval.tv_usec/10000)<<" s";       
        { // Ici il y a 0 secondes
          if ( ATimeval.tv_usec>1500 )
                  res<<std::setprecision(2)<<std::fixed
                                  <<ATimeval.tv_usec/1000.<<" ms (10-3 s)";
          else
            res<<ATimeval.tv_usec<<" us (10-6 s)";
        }
    }

  return res.str();
}
//******************************************************************************
inline
std::string CChrono::getTime ( const std::string& AMessage )
{
  bool rerun = false;
  std::ostringstream res;

  if ( FRun )
    {
      rerun = true;
      stop();
    }
  
  res<<AMessage<<" : ";
  if ( FMode==PUS_MODE || FMode==REEL_AND_PUS_MODE )
    {
      res<<convertTimeval(FTotalPus.ru_utime)<<" user, ";  
      res<<convertTimeval(FTotalPus.ru_stime)<<" sys";
    }
  
        if ( FMode==REEL_AND_PUS_MODE ) res<<", ";
        
  if ( FMode==REEL_MODE || FMode==REEL_AND_PUS_MODE )
    res<<convertTimeval(FTotalReel)<<" reel";

  if ( rerun )
    start();
  
  return res.str();
}
//------------------------------------------------------------------------------
inline
void CChrono::display ( const std::string& AMessage )
{  std::cout<<getTime(AMessage)<<std::endl; }
//******************************************************************************
#endif // CHRONO_HH
//******************************************************************************

---