Timing.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/Kernel.h>
#include <GaudiKernel/SystemBase.h>
 
#include <sys/time.h>

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

  GAUDI_API long long adjustTime( TimeType typ, long long timevalue );

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

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

  template <TimeType T>
  GAUDI_API long long currentTime();

  GAUDI_API long long currentTime( TimeType typ = milliSec );

  GAUDI_API long long 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 );
} // namespace System
 
// 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 long long currentTime() {
    struct timeval tv;
    ::gettimeofday( &tv, 0 );
    return adjustTime<T>( ( tv.tv_sec * 1000000 + tv.tv_usec ) * 10 );
  }
 
  // Define all template versions here to avoid code bloat
  template long long currentTime<Year>();
  template long long currentTime<Month>();
  template long long currentTime<Day>();
  template long long currentTime<Hour>();
  template long long currentTime<Min>();
  template long long currentTime<Sec>();
  template long long currentTime<milliSec>();
  template long long currentTime<microSec>();
  template long long currentTime<nanoSec>();
  template long long currentTime<Native>();
} // namespace System