qt_demoe/qwtdemo/qwt/qwt_system_clock.cpp

397 lines
7.9 KiB
C++
Raw Normal View History

2019-11-07 02:55:57 +00:00
/* -*- mode: C++ ; c-file-style: "stroustrup" -*- *****************************
* Qwt Widget Library
* Copyright (C) 1997 Josef Wilgen
* Copyright (C) 2002 Uwe Rathmann
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the Qwt License, Version 1.0
*****************************************************************************/
#include "qwt_system_clock.h"
#if QT_VERSION >= 0x040800
#define USE_ELAPSED_TIMER 1
#endif
#if USE_ELAPSED_TIMER
#include <qelapsedtimer.h>
class QwtSystemClock::PrivateData
{
public:
QElapsedTimer timer;
};
QwtSystemClock::QwtSystemClock()
{
d_data = new PrivateData();
}
QwtSystemClock::~QwtSystemClock()
{
delete d_data;
}
bool QwtSystemClock::isNull() const
{
return d_data->timer.isValid();
}
void QwtSystemClock::start()
{
d_data->timer.start();
}
double QwtSystemClock::restart()
{
const qint64 nsecs = d_data->timer.restart();
return nsecs / 1e6;
}
double QwtSystemClock::elapsed() const
{
const qint64 nsecs = d_data->timer.nsecsElapsed();
return nsecs / 1e6;
}
#else // !USE_ELAPSED_TIMER
#include <qdatetime.h>
#if !defined(Q_OS_WIN)
#include <unistd.h>
#endif
#if defined(Q_OS_MAC)
#include <stdint.h>
#include <mach/mach_time.h>
#define QWT_HIGH_RESOLUTION_CLOCK
#elif defined(_POSIX_TIMERS)
#include <time.h>
#define QWT_HIGH_RESOLUTION_CLOCK
#elif defined(Q_OS_WIN)
#define QWT_HIGH_RESOLUTION_CLOCK
#include <qt_windows.h>
#endif
#if defined(QWT_HIGH_RESOLUTION_CLOCK)
class QwtHighResolutionClock
{
public:
QwtHighResolutionClock();
void start();
double restart();
double elapsed() const;
bool isNull() const;
static double precision();
private:
#if defined(Q_OS_MAC)
static double msecsTo( uint64_t, uint64_t );
uint64_t d_timeStamp;
#elif defined(_POSIX_TIMERS)
static double msecsTo( const struct timespec &,
const struct timespec & );
static bool isMonotonic();
struct timespec d_timeStamp;
clockid_t d_clockId;
#elif defined(Q_OS_WIN)
LARGE_INTEGER d_startTicks;
LARGE_INTEGER d_ticksPerSecond;
#endif
};
#if defined(Q_OS_MAC)
QwtHighResolutionClock::QwtHighResolutionClock():
d_timeStamp( 0 )
{
}
double QwtHighResolutionClock::precision()
{
return 1e-6;
}
void QwtHighResolutionClock::start()
{
d_timeStamp = mach_absolute_time();
}
double QwtHighResolutionClock::restart()
{
const uint64_t timeStamp = mach_absolute_time();
const double elapsed = msecsTo( d_timeStamp, timeStamp );
d_timeStamp = timeStamp;
return elapsed;
}
double QwtHighResolutionClock::elapsed() const
{
return msecsTo( d_timeStamp, mach_absolute_time() );
}
bool QwtHighResolutionClock::isNull() const
{
return d_timeStamp == 0;
}
double QwtHighResolutionClock::msecsTo(
uint64_t from, uint64_t to )
{
const uint64_t difference = to - from;
static double conversion = 0.0;
if ( conversion == 0.0 )
{
mach_timebase_info_data_t info;
kern_return_t err = mach_timebase_info( &info );
// convert the timebase into ms
if ( err == 0 )
conversion = 1e-6 * ( double ) info.numer / ( double ) info.denom;
}
return conversion * ( double ) difference;
}
#elif defined(_POSIX_TIMERS)
QwtHighResolutionClock::QwtHighResolutionClock()
{
d_clockId = isMonotonic() ? CLOCK_MONOTONIC : CLOCK_REALTIME;
d_timeStamp.tv_sec = d_timeStamp.tv_nsec = 0;
}
double QwtHighResolutionClock::precision()
{
struct timespec resolution;
int clockId = isMonotonic() ? CLOCK_MONOTONIC : CLOCK_REALTIME;
::clock_getres( clockId, &resolution );
return resolution.tv_nsec / 1e3;
}
inline bool QwtHighResolutionClock::isNull() const
{
return d_timeStamp.tv_sec <= 0 && d_timeStamp.tv_nsec <= 0;
}
inline void QwtHighResolutionClock::start()
{
::clock_gettime( d_clockId, &d_timeStamp );
}
double QwtHighResolutionClock::restart()
{
struct timespec timeStamp;
::clock_gettime( d_clockId, &timeStamp );
const double elapsed = msecsTo( d_timeStamp, timeStamp );
d_timeStamp = timeStamp;
return elapsed;
}
inline double QwtHighResolutionClock::elapsed() const
{
struct timespec timeStamp;
::clock_gettime( d_clockId, &timeStamp );
return msecsTo( d_timeStamp, timeStamp );
}
inline double QwtHighResolutionClock::msecsTo(
const struct timespec &t1, const struct timespec &t2 )
{
return ( t2.tv_sec - t1.tv_sec ) * 1e3
+ ( t2.tv_nsec - t1.tv_nsec ) * 1e-6;
}
bool QwtHighResolutionClock::isMonotonic()
{
// code copied from qcore_unix.cpp
#if (_POSIX_MONOTONIC_CLOCK-0 > 0)
return true;
#else
static int returnValue = 0;
if ( returnValue == 0 )
{
#if (_POSIX_MONOTONIC_CLOCK-0 < 0) || !defined(_SC_MONOTONIC_CLOCK)
returnValue = -1;
#elif (_POSIX_MONOTONIC_CLOCK == 0)
// detect if the system support monotonic timers
const long x = sysconf( _SC_MONOTONIC_CLOCK );
returnValue = ( x >= 200112L ) ? 1 : -1;
#endif
}
return returnValue != -1;
#endif
}
#elif defined(Q_OS_WIN)
QwtHighResolutionClock::QwtHighResolutionClock()
{
d_startTicks.QuadPart = 0;
QueryPerformanceFrequency( &d_ticksPerSecond );
}
double QwtHighResolutionClock::precision()
{
LARGE_INTEGER ticks;
if ( QueryPerformanceFrequency( &ticks ) && ticks.QuadPart > 0 )
return 1e3 / ticks.QuadPart;
return 0.0;
}
inline bool QwtHighResolutionClock::isNull() const
{
return d_startTicks.QuadPart <= 0;
}
inline void QwtHighResolutionClock::start()
{
QueryPerformanceCounter( &d_startTicks );
}
inline double QwtHighResolutionClock::restart()
{
LARGE_INTEGER ticks;
QueryPerformanceCounter( &ticks );
const double dt = ticks.QuadPart - d_startTicks.QuadPart;
d_startTicks = ticks;
return dt / d_ticksPerSecond.QuadPart * 1e3;
}
inline double QwtHighResolutionClock::elapsed() const
{
LARGE_INTEGER ticks;
QueryPerformanceCounter( &ticks );
const double dt = ticks.QuadPart - d_startTicks.QuadPart;
return dt / d_ticksPerSecond.QuadPart * 1e3;
}
#endif
#endif // QWT_HIGH_RESOLUTION_CLOCK
class QwtSystemClock::PrivateData
{
public:
#if defined(QWT_HIGH_RESOLUTION_CLOCK)
QwtHighResolutionClock *clock;
#endif
QTime time;
};
//! Constructs a null clock object.
QwtSystemClock::QwtSystemClock()
{
d_data = new PrivateData;
#if defined(QWT_HIGH_RESOLUTION_CLOCK)
d_data->clock = NULL;
if ( QwtHighResolutionClock::precision() > 0.0 )
d_data->clock = new QwtHighResolutionClock;
#endif
}
//! Destructor
QwtSystemClock::~QwtSystemClock()
{
#if defined(QWT_HIGH_RESOLUTION_CLOCK)
delete d_data->clock;
#endif
delete d_data;
}
/*!
\return true if the clock has never been started.
*/
bool QwtSystemClock::isNull() const
{
#if defined(QWT_HIGH_RESOLUTION_CLOCK)
if ( d_data->clock )
return d_data->clock->isNull();
#endif
return d_data->time.isNull();
}
/*!
Sets the start time to the current time.
*/
void QwtSystemClock::start()
{
#if defined(QWT_HIGH_RESOLUTION_CLOCK)
if ( d_data->clock )
{
d_data->clock->start();
return;
}
#endif
d_data->time.start();
}
/*!
Set the start time to the current time
\return Time, that is elapsed since the previous start time.
*/
double QwtSystemClock::restart()
{
#if defined(QWT_HIGH_RESOLUTION_CLOCK)
if ( d_data->clock )
return d_data->clock->restart();
#endif
return d_data->time.restart();
}
/*!
\return Number of milliseconds that have elapsed since the last time
start() or restart() was called or 0.0 for null clocks.
*/
double QwtSystemClock::elapsed() const
{
double elapsed = 0.0;
#if defined(QWT_HIGH_RESOLUTION_CLOCK)
if ( d_data->clock )
{
if ( !d_data->clock->isNull() )
elapsed = d_data->clock->elapsed();
return elapsed;
}
#endif
if ( !d_data->time.isNull() )
elapsed = d_data->time.elapsed();
return elapsed;
}
#endif