Timing.h

Go to the documentation of this file.

//====================================================================
//  Timing.h
//--------------------------------------------------------------------
//
//  Package    : Gaudi/System (The LHCb System service)
//
//  Description: Definition of Systems internals
//
//  Author     : M.Frank
//      Created    : 13/1/99
//====================================================================
#ifndef GAUDIKERNEL_TIMING_H
#define GAUDIKERNEL_TIMING_H

// Framework include files
#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/SystemBase.h"

#ifdef _WIN32
#include <windows.h>
#else
#include <sys/time.h>
#endif

namespace System
{
  enum TimeType { Year, Month, Day, Hour, Min, Sec, milliSec, microSec, nanoSec, Native };

  GAUDI_API longlong adjustTime( TimeType typ, longlong timevalue );

  template <TimeType T>
  inline long long adjustTime( long long timevalue );

  GAUDI_API longlong ellapsedTime( TimeType typ = milliSec, InfoType fetch = Times, long pid = -1 );
  GAUDI_API longlong kernelTime( TimeType typ = milliSec, InfoType fetch = Times, long pid = -1 );
  GAUDI_API longlong userTime( TimeType typ = milliSec, InfoType fetch = Times, long pid = -1 );
  GAUDI_API longlong cpuTime( TimeType typ = milliSec, InfoType fetch = Times, long pid = -1 );
  GAUDI_API longlong remainingTime( TimeType typ = milliSec, InfoType fetch = Quota, long pid = -1 );
  GAUDI_API longlong creationTime( TimeType typ = milliSec, InfoType fetch = Times, long pid = -1 );
  GAUDI_API longlong systemStart( TimeType typ = Sec );
  GAUDI_API longlong upTime( TimeType typ = Hour );
  template <TimeType T>
  GAUDI_API longlong currentTime();

  GAUDI_API longlong currentTime( TimeType typ = milliSec );

  GAUDI_API longlong tickCount();

  class ProcessTime
  {
  public:
    typedef long long TimeValueType;

    ProcessTime() : i_kernel( 0 ), i_user( 0 ), i_elapsed( 0 ) {}

    ProcessTime( TimeValueType k, TimeValueType u, TimeValueType e ) : i_kernel( k ), i_user( u ), i_elapsed( e ) {}

    template <TimeType   T>
    inline TimeValueType kernelTime() const
    {
      return adjustTime<T>( i_kernel );
    }

    template <TimeType   T>
    inline TimeValueType userTime() const
    {
      return adjustTime<T>( i_user );
    }

    template <TimeType   T>
    inline TimeValueType elapsedTime() const
    {
      return adjustTime<T>( i_elapsed );
    }

    template <TimeType   T>
    inline TimeValueType cpuTime() const
    {
      return adjustTime<T>( i_user + i_kernel );
    }

    inline ProcessTime operator-( const ProcessTime& rhs ) const
    {
      return ProcessTime( i_kernel - rhs.i_kernel, i_user - rhs.i_user, i_elapsed - rhs.i_elapsed );
    }
    inline ProcessTime& operator+=( const ProcessTime& rhs )
    {
      i_kernel += rhs.i_kernel;
      i_user += rhs.i_user;
      i_elapsed += rhs.i_elapsed;
      return *this;
    }

  private:
    TimeValueType i_kernel, i_user, i_elapsed;
  };

  GAUDI_API ProcessTime getProcessTime( long pid = -1 );
}

// implementation of the templated functions
namespace System
{
  template <>
  inline long long adjustTime<Year>( long long t )
  {
    return ( t == -1 ) ? t : t /= ( 1LL * 365 * 24 * 60 * 60 * 1000 * 1000 * 10 );
  }
  template <>
  inline long long adjustTime<Day>( long long t )
  {
    return ( t == -1 ) ? t : t /= ( 1LL * 24 * 60 * 60 * 1000 * 1000 * 10 );
  }
  template <>
  inline long long adjustTime<Hour>( long long t )
  {
    return ( t == -1 ) ? t : t /= ( 1LL * 60 * 60 * 1000 * 1000 * 10 );
  }
  template <>
  inline long long adjustTime<Min>( long long t )
  {
    return ( t == -1 ) ? t : t /= ( 60 * 1000 * 1000 * 10 );
  }
  template <>
  inline long long adjustTime<Sec>( long long t )
  {
    return ( t == -1 ) ? t : t /= ( 1000 * 1000 * 10 );
  }
  template <>
  inline long long adjustTime<milliSec>( long long t )
  {
    return ( t == -1 ) ? t : t /= ( 1000 * 10 );
  }
  template <>
  inline long long adjustTime<microSec>( long long t )
  {
    return ( t == -1 ) ? t : t /= ( 10LL );
  }
  template <>
  inline long long adjustTime<nanoSec>( long long t )
  {
    return ( t == -1 ) ? t : t *= 100LL;
  }
  template <>
  inline long long adjustTime<Month>( long long t )
  {
    return ( t == -1 ) ? t : t /= ( 1LL * 30 * 24 * 60 * 60 * 1000 * 1000 * 10 );
  }
  template <>
  inline long long adjustTime<Native>( long long t )
  {
    return t;
  }

  // This is frequently used and thus we inline it if possible
  template <TimeType T>
  inline longlong    currentTime()
  {
#ifdef _WIN32
    longlong current = 0;
    ::GetSystemTimeAsFileTime( (FILETIME*)&current );
    return adjustTime<T>( current - UNIX_BASE_TIME );
#else
    struct timeval tv;
    ::gettimeofday( &tv, 0 );
    return adjustTime<T>( ( tv.tv_sec * 1000000 + tv.tv_usec ) * 10 );
#endif
  }

  // Define all template versions here to avoid code bloat
  template longlong currentTime<Year>();
  template longlong currentTime<Month>();
  template longlong currentTime<Day>();
  template longlong currentTime<Hour>();
  template longlong currentTime<Min>();
  template longlong currentTime<Sec>();
  template longlong currentTime<milliSec>();
  template longlong currentTime<microSec>();
  template longlong currentTime<nanoSec>();
  template longlong currentTime<Native>();
}

#endif // GAUDIKERNEL_TIMING_H