Line data    Source code

       1             : #include "crpropa/Clock.h"
       2             : 
       3             : #if defined(WIN32) || defined(_WIN32)
       4             : 
       5             : #define USE_WINDOWS_TIMERS
       6             : #define WIN32_LEAN_AND_MEAN
       7             : #define NOWINRES
       8             : #define NOMCX
       9             : #define NOIME
      10             : #ifdef _XBOX
      11             : #include <Xtl.h>
      12             : #else
      13             : #include <windows.h>
      14             : #endif
      15             : #include <ctime>
      16             : 
      17             : #else
      18             : #include <sys/time.h>
      19             : #endif
      20             : 
      21             : #include <algorithm>
      22             : #ifdef _OPENMP
      23             : #include <omp.h>
      24             : #include <stdexcept>
      25             : #endif
      26             : 
      27             : namespace crpropa {
      28             : 
      29             : #ifdef WIN32
      30             : class Clock::Impl {
      31             :         LARGE_INTEGER clockFrequency;
      32             :         DWORD startTick;
      33             :         LONGLONG prevElapsedTime;
      34             :         LARGE_INTEGER startTime;
      35             : public:
      36             :         Impl() {
      37             :                 QueryPerformanceFrequency(&clockFrequency);
      38             :                 reset();
      39             :         }
      40             : 
      41             :         void reset() {
      42             :                 QueryPerformanceCounter(&startTime);
      43             :                 startTick = GetTickCount();
      44             :                 prevElapsedTime = 0;
      45             :         }
      46             : 
      47             :         /// Returns the time in ms since the last call to reset or since
      48             :         /// the btClock was created.
      49             :         double getSecond() {
      50             :                 LARGE_INTEGER currentTime;
      51             :                 QueryPerformanceCounter(&currentTime);
      52             :                 LONGLONG elapsedTime = currentTime.QuadPart - startTime.QuadPart;
      53             : 
      54             :                 // Compute the number of millisecond ticks elapsed.
      55             :                 unsigned long msecTicks = (unsigned long) (1000 * elapsedTime
      56             :                                 / clockFrequency.QuadPart);
      57             : 
      58             :                 // Check for unexpected leaps in the Win32 performance counter.
      59             :                 // (This is caused by unexpected data across the PCI to ISA
      60             :                 // bridge, aka south bridge.  See Microsoft KB274323.)
      61             :                 unsigned long elapsedTicks = GetTickCount() - startTick;
      62             :                 signed long msecOff = (signed long) (msecTicks - elapsedTicks);
      63             :                 if (msecOff < -100 || msecOff > 100) {
      64             :                         // Adjust the starting time forwards.
      65             :                         LONGLONG msecAdjustment = std::min(
      66             :                                         msecOff * clockFrequency.QuadPart / 1000,
      67             :                                         elapsedTime - prevElapsedTime);
      68             :                         startTime.QuadPart += msecAdjustment;
      69             :                         elapsedTime -= msecAdjustment;
      70             :                 }
      71             : 
      72             :                 // Store the current elapsed time for adjustments next time.
      73             :                 prevElapsedTime = elapsedTime;
      74             : 
      75             :                 // Convert to microseconds.
      76             :                 unsigned long usecTicks = (unsigned long) (1000000 * elapsedTime
      77             :                                 / clockFrequency.QuadPart);
      78             : 
      79             :                 return double(usecTicks) / 1000000;
      80             :         }
      81             : };
      82             : #else
      83             : 
      84             : class Clock::Impl {
      85             :         struct timeval startTime;
      86             : public:
      87           0 :         Impl() {
      88             :                 reset();
      89             :         }
      90             : 
      91             :         void reset() {
      92           0 :                 gettimeofday(&startTime, 0);
      93             :         }
      94             : 
      95             :         /// Returns the time in since the last call to reset or since
      96             :         /// the btClock was created.
      97           0 :         double getTime() {
      98             :                 struct timeval currentTime;
      99           0 :                 gettimeofday(&currentTime, 0);
     100           0 :                 double t = double(currentTime.tv_sec - startTime.tv_sec);
     101           0 :                 t += double(currentTime.tv_usec - startTime.tv_usec) / 1000000.;
     102           0 :                 return t;
     103             :         }
     104             : };
     105             : #endif
     106             : 
     107           0 : Clock::Clock() {
     108           0 :         impl = new Impl;
     109           0 : }
     110             : 
     111           0 : Clock::~Clock() {
     112           0 :         delete impl;
     113           0 : }
     114             : 
     115           0 : void Clock::reset() {
     116           0 :         impl->reset();
     117           0 : }
     118             : 
     119           0 : double Clock::getSecond() {
     120           0 :         return impl->getTime();
     121             : }
     122             : 
     123           0 : double Clock::getMillisecond() {
     124           0 :         return impl->getTime() * 1000;
     125             : }
     126             : 
     127             : #ifdef _OPENMP
     128             : 
     129             : // see http://stackoverflow.com/questions/8051108/using-the-openmp-threadprivate-directive-on-static-instances-of-c-stl-types
     130             : const static int MAX_THREAD = 256;
     131             : 
     132           0 : struct CLOCK_TLS_ITEM {
     133             :         Clock r;
     134             :         char padding[(sizeof(Clock) / 64 + 1) * 64 - sizeof(Clock)];
     135             : };
     136             : 
     137           0 : Clock &Clock::getInstance() {
     138             : #ifdef _MSC_VER
     139             :         __declspec(align(64)) static CLOCK_TLS_ITEM tls[MAX_THREAD];
     140             : #else
     141           0 :         __attribute__ ((aligned(64))) static CLOCK_TLS_ITEM tls[MAX_THREAD];
     142             : #endif
     143           0 :         int i = omp_get_thread_num();
     144           0 :         if (i >= MAX_THREAD)
     145           0 :         throw std::runtime_error("crpropa::Clock: more than MAX_THREAD threads!");
     146           0 :         return tls[i].r;
     147             : }
     148             : #else
     149             : Clock &Clock::getInstance() {
     150             :         static Clock r;
     151             :         return r;
     152             : }
     153             : #endif
     154             : 
     155             : } /* namespace scs */