timing.h

Go to the documentation of this file.

// $Id: timing.h 4482 2020-04-15 14:47:18Z linev $
 
/************************************************************
 * The Data Acquisition Backbone Core (DABC)                *
 ************************************************************
 * Copyright (C) 2009 -                                     *
 * GSI Helmholtzzentrum fuer Schwerionenforschung GmbH      *
 * Planckstr. 1, 64291 Darmstadt, Germany                   *
 * Contact:  http://dabc.gsi.de                             *
 ************************************************************
 * This software can be used under the GPL license          *
 * agreements as stated in LICENSE.txt file                 *
 * which is part of the distribution.                       *
 ************************************************************/
 
#ifndef DABC_timing
#define DABC_timing
 
#ifndef DABC_string
#include "dabc/string.h"
#endif
 
namespace dabc {
 
   class Profiler;
 
   struct TimeStamp {
 
      friend class Profiler;
 
      protected:
         double fValue;  
 
         static bool gFast;  
 
         typedef long long int slowclock_t;
 
         static slowclock_t gSlowClockZero;
 
         static slowclock_t GetSlowClock();
 
         #if defined (__x86_64__) || defined(__i386__)
         typedef unsigned long long fastclock_t;
         static inline fastclock_t GetFastClock()
         {
            unsigned low, high;
            asm volatile ("rdtsc" : "=a" (low), "=d" (high));
            return (fastclock_t(high) << 32) | low;
         }
         #elif defined(__PPC__) || defined(__PPC64__)
         typedef unsigned long fastclock_t;
         static inline fastclock_t GetFastClock()
         {
            fastclock_t ret;
            asm volatile ("mftb %0" : "=r" (ret) : );
            return ret;
         }
         #elif defined(__ia64__)
         typedef unsigned long fastclock_t;
         static inline fastclock_t GetFastClock()
         {
            fastclock_t ret;
            asm volatile ("mov %0=ar.itc" : "=r" (ret));
            return ret;
         }
         #else
         typedef slowclock_t fastclock_t;
         static inline fastclock_t GetFastClock() { return GetSlowClock(); }
         #endif
 
         static fastclock_t gFastClockZero;
         static double gFastClockMult;
 
         static double CalculateFastClockMult();
 
         static bool CheckLinuxTSC();
 
         TimeStamp(double v) : fValue(v) {}
 
         static inline TimeStamp Slow() { return TimeStamp((GetSlowClock() - gSlowClockZero) * 1e-9); }
 
         static inline TimeStamp Fast() { return TimeStamp((GetFastClock() - gFastClockZero) * gFastClockMult); }
 
      public:
 
         TimeStamp() : fValue(0)  {}
 
         TimeStamp(const TimeStamp& src) : fValue(src.fValue) {}
 
         TimeStamp& operator=(const TimeStamp& src) { fValue = src.fValue; return *this; }
 
         TimeStamp& operator+=(double _add) { fValue+=_add; return *this; }
 
         TimeStamp& operator-=(double _sub) { fValue-=_sub; return *this; }
 
         TimeStamp operator+(double _add) const { return TimeStamp(fValue+_add); }
 
         TimeStamp operator-(double _sub) const { return TimeStamp(fValue-_sub); }
 
         double operator()() const { return fValue; }
 
         double AsDouble() const { return fValue; }
 
         double operator-(const TimeStamp& src) const { return fValue - src.fValue; }
 
         bool operator<(const TimeStamp& src) const { return fValue < src.fValue; }
 
         bool operator>(const TimeStamp& src) const { return fValue > src.fValue; }
 
         bool operator==(const TimeStamp& src) const { return fValue == src.fValue; }
 
         bool null() const { return fValue <= 0.; }
 
         void Reset() { fValue = 0.; }
 
         inline void GetNow() { fValue = gFast ? (GetFastClock() - gFastClockZero) * gFastClockMult : (GetSlowClock() - gSlowClockZero) * 1e-9; }
 
         inline void GetNow(double shift) { GetNow(); fValue += shift;  }
 
         inline double SpentTillNow() const
         {
            return null() ? 0 : Now().AsDouble() - AsDouble();
         }
 
         inline double SpentTillNow(bool set_to_now)
         {
            double res = 0.;
            TimeStamp now = Now();
            if (!null()) res = now.AsDouble() - AsDouble();
            if (set_to_now) *this = now;
            return res;
         }
 
         inline bool Expired(double interval = 0.) const { return Now().AsDouble() > AsDouble() + interval; }
 
         inline bool Expired(const TimeStamp& curr, double interval) const { return curr.AsDouble() > AsDouble() + interval; }
 
         static inline TimeStamp Now() { return gFast ? Fast() : Slow(); }
 
         static void SetUseSlow() { gFast = false; }
   };
 
   // ==========================================================================
 
   class DateTime {
      protected:
         unsigned tv_sec;   // GMT time in seconds, since 1.1.1970
         unsigned tv_nsec;  // fractional part of time in nanoseconds
      public:
         DateTime() : tv_sec(0), tv_nsec(0) {}
 
         DateTime(uint64_t jsdate) : tv_sec(0), tv_nsec(0) { SetJSDate(jsdate); }
 
         DateTime(const DateTime& src) : tv_sec(src.tv_sec), tv_nsec(src.tv_nsec) {}
 
         DateTime& operator=(const DateTime& src)
         {
            tv_sec = src.tv_sec;
            tv_nsec = src.tv_nsec;
            return *this;
         }
 
         double operator-(const DateTime& src) const { return src.DistanceTo(*this); }
 
         bool null() const { return (tv_sec==0) && (tv_nsec==0); }
 
         DateTime& GetNow();
 
         double AsDouble() const;
 
         uint64_t AsJSDate() const;
 
         unsigned AsUTCSeconds() const { return tv_sec; }
 
         void SetJSDate(uint64_t jsdate)
         {
            tv_sec = jsdate / 1000;
            tv_nsec = ((jsdate % 1000)*1000000);
         }
 
         void SetDouble(double v)
         {
            SetJSDate(v > 0 ? (uint64_t) v * 1000 : 0);
         }
 
         std::string AsString(int ndecimal = 0, bool localtime = false) const;
 
         std::string AsJSString(int ndecimal = 3) const;
 
         std::string OnlyDateAsString(const char *separ = nullptr, bool localtime = false) const;
 
         std::string OnlyTimeAsString(const char *separ = nullptr, bool localtime = false) const;
 
         bool SetOnlyDate(const char* sbuf);
 
         bool SetOnlyTime(const char* sbuf);
 
         double DistanceTo(const DateTime& src) const;
   };
 
   inline TimeStamp Now() { return TimeStamp::Now(); }
 
   void Sleep(double tm);
}
 
#endif