ElapsedTime.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.7.0
// ----------------------------------------------------------------------------
// pcl/ElapsedTime.h - Released 2024-06-18T15:48:54Z
// ----------------------------------------------------------------------------
// This file is part of the PixInsight Class Library (PCL).
// PCL is a multiplatform C++ framework for development of PixInsight modules.
//
// Copyright (c) 2003-2024 Pleiades Astrophoto S.L. All Rights Reserved.
//
// Redistribution and use in both source and binary forms, with or without
// modification, is permitted provided that the following conditions are met:
//
// 1. All redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. All redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
//    of their contributors, may be used to endorse or promote products derived
//    from this software without specific prior written permission. For written
//    permission, please contact info@pixinsight.com.
//
// 4. All products derived from this software, in any form whatsoever, must
//    reproduce the following acknowledgment in the end-user documentation
//    and/or other materials provided with the product:
//
//    "This product is based on software from the PixInsight project, developed
//    by Pleiades Astrophoto and its contributors (https://pixinsight.com/)."
//
//    Alternatively, if that is where third-party acknowledgments normally
//    appear, this acknowledgment must be reproduced in the product itself.
//
// THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PLEIADES ASTROPHOTO OR ITS
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
// INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
// DATA OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
// ----------------------------------------------------------------------------
 
#ifndef __PCL_ElapsedTime_h
#define __PCL_ElapsedTime_h
 
 
#include <pcl/Defs.h>
#include <pcl/Diagnostics.h>
 
#include <pcl/String.h>
 
#if !defined( __PCL_LINUX ) && !defined( __PCL_FREEBSD )
#  include <pcl/Atomic.h>
#  include <pcl/AutoLock.h>
#  define PCL_CLOCK_ID 0
#endif
 
#ifdef __PCL_LINUX
#  include <time.h>
#  ifdef CLOCK_MONOTONIC_RAW // since kernel 2.6.28
#    define PCL_CLOCK_ID CLOCK_MONOTONIC_RAW
#  else
#    define PCL_CLOCK_ID CLOCK_MONOTONIC
#  endif
#endif
 
#ifdef __PCL_FREEBSD
#  include <sys/timespec.h>
#  ifdef CLOCK_MONOTONIC_PRECISE // since FreeBSD 10.1
#    define PCL_CLOCK_ID CLOCK_MONOTONIC_PRECISE
#  else
#    define PCL_CLOCK_ID CLOCK_MONOTONIC
#  endif
#endif
 
#ifdef __PCL_MACOSX
#  include <mach/mach.h>
#  include <mach/mach_time.h>
#endif
 
namespace pcl
{
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS ElapsedTime
{
public:
 
   ElapsedTime()
   {
      Reset();
   }
 
   ElapsedTime( const ElapsedTime& ) = default;
 
   ElapsedTime& operator =( const ElapsedTime& ) = default;
 
   double operator ()() const
   {
      return TimeStamp() - m_start;
   }
 
   void Reset()
   {
      m_start = TimeStamp();
   }
 
   IsoString ToIsoString() const
   {
      return ToIsoString( operator()() );
   }
 
   String ToString() const
   {
      return ToString( operator()() );
   }
 
   operator IsoString() const
   {
      return ToIsoString();
   }
 
   operator String() const
   {
      return ToString();
   }
 
   static double TimeStamp()
   {
#if defined( __PCL_LINUX ) || defined( __PCL_FREEBSD )
 
      /*
       * Linux/FreeBSD implementation based on clock_gettime().
       */
      timespec ts;
      (void)clock_gettime( PCL_CLOCK_ID, &ts );
      return ts.tv_sec + ts.tv_nsec*1.0e-09;
 
#endif   // __PCL_LINUX || __PCL_FREEBSD
 
#ifdef __PCL_MACOSX
 
      /*
       * macOS implementation based on Mach absolute time system services.
       *
       * https://developer.apple.com/library/mac/qa/qa1398/_index.html
       * http://stackoverflow.com/questions/5167269/clock-gettime-alternative-in-mac-os-x
       */
      static Mutex     mutex;
      static AtomicInt initialized;
      static double    absoluteToSeconds;
      static uint64    offset;
 
      if ( !initialized )
      {
         volatile AutoLock lock( mutex );
         if ( initialized.Load() == 0 )
         {
            mach_timebase_info_data_t timeBase = { 0 };
            mach_timebase_info( &timeBase );
            absoluteToSeconds = 1.0e-09*(double( timeBase.numer )/timeBase.denom);
            offset = mach_absolute_time();
            initialized.Store( 1 );
         }
      }
 
      uint64 t = mach_absolute_time();
      return (t - offset)*absoluteToSeconds;
 
#endif   // __PCL_MACOSX
 
#ifdef __PCL_WINDOWS
 
      /*
       * Windows implementation based on Win32 performance counters.
       *
       * https://msdn.microsoft.com/en-us/library/windows/desktop/ms644905%28v=vs.85%29.aspx
       * https://msdn.microsoft.com/en-us/library/windows/desktop/ms644904%28v=vs.85%29.aspx
       * http://stackoverflow.com/questions/5404277/porting-clock-gettime-to-windows
       * http://stackoverflow.com/questions/1676036/what-should-i-use-to-replace-gettimeofday-on-windows
       */
      static Mutex     mutex;
      static AtomicInt initialized;
      static double    countsToSeconds;
      static uint64    offset;
 
      if ( !initialized )
      {
         volatile AutoLock lock( mutex );
         if ( initialized.Load() == 0 )
         {
            uint64 performanceFrequency;
            QueryPerformanceFrequency( (LARGE_INTEGER*)&performanceFrequency );
            countsToSeconds = 1.0/performanceFrequency;
            QueryPerformanceCounter( (LARGE_INTEGER*)&offset );
            initialized.Store( 1 );
         }
      }
 
      uint64 t;
      QueryPerformanceCounter( (LARGE_INTEGER*)&t );
      return (t - offset)*countsToSeconds;
 
#endif   // __PCL_WINDOWS
   }
 
   static IsoString ToIsoString( double seconds, int width = 0, int precision = 3 )
   {
      return ToString( seconds, width, precision, (IsoString*)0 );
   }
 
   static String ToString( double s, int width = 0, int precision = 3 )
   {
      return ToString( s, width, precision, (String*)0 );
   }
 
   friend double operator -( const ElapsedTime& t1, const ElapsedTime& t2 )
   {
      return t1.m_start - t2.m_start;
   }
 
private:
 
   double m_start; // timestamp in seconds
 
   template <class S>
   static S ToString( double s, int w, int p, S* )
   {
      w = Max( 0, w );
      p = Range( p, 0, 3 );
 
      if ( s < 60 )
      {
         if ( w > 0 )
            if ( p > 0 )
               w = Max( p+2, w+p+1 );
 
         const char* u;
         if ( s < 0.001 )
         {
            s *= 1000000;
            u = "us";
         }
         else if ( s < 1 )
         {
            s *= 1000;
            u = "ms";
         }
         else
            u = "s";
 
         if ( w > 0 )
            return S().Format( "%*.*f %s", w, p, s, u );
         return S().Format( "%.*f %s", p, s, u );
      }
 
      int sign = (s < 0) ? -1 : +1;
      s = Abs( s );
 
      if ( s < 3600 )
      {
         int m = TruncInt( s/60 );
         s -= m*60;
         p = Max( 0, p-1 );
         return S().Format( "%02d:%0*.*f", m*sign, (p > 0) ? 3+p : 2, p, s );
      }
 
      if ( s < 86400 )
      {
         int h = TruncInt( s/3600 );
         s -= h*3600;
         int m = TruncInt( s/60 );
         s -= m*60;
         p = Max( 0, p-2 );
         return S().Format( "%02d:%02d:%0*.*f", h*sign, m, (p > 0) ? 3+p : 2, p, s );
      }
 
      int d = TruncInt( s/86400 );
      s -= d*86400;
      int h = TruncInt( s/3600 );
      s -= h*3600;
      int m = TruncInt( s/60 );
      s -= m*60;
      return S().Format( "%d:%02d:%02d:%02d", d*sign, h, m, RoundInt( s ) );
   }
};
 
// ----------------------------------------------------------------------------
 
} // pcl
 
#endif   // __PCL_ElapsedTime_h
 
// ----------------------------------------------------------------------------
// EOF pcl/ElapsedTime.h - Released 2024-06-18T15:48:54Z