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