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"

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);
  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);
    }
  private:
    TimeValueType i_kernel, i_user, i_elapsed;
  };

  GAUDI_API ProcessTime getProcessTime(long pid = -1);

}

// implementation of the templated adjustTime
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;
  }
}

#endif    // GAUDIKERNEL_TIMING_H