1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
|
// Copyright (C) 2016 The Qt Company Ltd.
// Copyright (C) 2016 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
#include "qelapsedtimer.h"
#include "qdeadlinetimer.h"
#include "qdeadlinetimer_p.h"
#if defined(Q_OS_VXWORKS)
#include "qfunctions_vxworks.h"
#else
#include <sys/time.h>
#include <time.h>
#endif
#include <unistd.h>
#include <qatomic.h>
#include "private/qcore_unix_p.h"
#if defined(QT_NO_CLOCK_MONOTONIC) || defined(QT_BOOTSTRAPPED)
// turn off the monotonic clock
# ifdef _POSIX_MONOTONIC_CLOCK
# undef _POSIX_MONOTONIC_CLOCK
# endif
# define _POSIX_MONOTONIC_CLOCK -1
#endif
QT_BEGIN_NAMESPACE
/*
* Design:
*
* POSIX offers a facility to select the system's monotonic clock when getting
* the current timestamp. Whereas the functions are mandatory in POSIX.1-2008,
* the presence of a monotonic clock is a POSIX Option (see the document
* http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap02.html#tag_02_01_06 )
*
* The macro _POSIX_MONOTONIC_CLOCK can therefore assume the following values:
* -1 monotonic clock is never supported on this system
* 0 monotonic clock might be supported, runtime check is needed
* >1 (such as 200809L) monotonic clock is always supported
*
* The unixCheckClockType() function will return the clock to use: either
* CLOCK_MONOTONIC or CLOCK_REALTIME. In the case the POSIX option has a value
* of zero, then this function stores a static that contains the clock to be
* used.
*
* There's one extra case, which is when CLOCK_REALTIME isn't defined. When
* that's the case, we'll emulate the clock_gettime function with gettimeofday.
*
* Conforming to:
* POSIX.1b-1993 section "Clocks and Timers"
* included in UNIX98 (Single Unix Specification v2)
* included in POSIX.1-2001
* see http://pubs.opengroup.org/onlinepubs/9699919799/functions/clock_getres.html
*/
#if !defined(CLOCK_REALTIME)
# define CLOCK_REALTIME 0
static inline void qt_clock_gettime(int, struct timespec *ts)
{
// support clock_gettime with gettimeofday
struct timeval tv;
gettimeofday(&tv, 0);
ts->tv_sec = tv.tv_sec;
ts->tv_nsec = tv.tv_usec * 1000;
}
static inline int regularClock()
{
return 0;
}
#else
static inline void qt_clock_gettime(clockid_t clock, struct timespec *ts)
{
clock_gettime(clock, ts);
}
static inline clock_t regularClockCheck()
{
struct timespec regular_clock_resolution;
int r = -1;
# ifdef CLOCK_MONOTONIC
// try the monotonic clock
r = clock_getres(CLOCK_MONOTONIC, ®ular_clock_resolution);
# ifdef Q_OS_LINUX
// Despite glibc claiming that we should check at runtime, the Linux kernel
// always supports the monotonic clock
Q_ASSERT(r == 0);
return CLOCK_MONOTONIC;
# endif
if (r == 0)
return CLOCK_MONOTONIC;
# endif
// no monotonic, try the realtime clock
r = clock_getres(CLOCK_REALTIME, ®ular_clock_resolution);
Q_ASSERT(r == 0);
return CLOCK_REALTIME;
}
static inline clock_t regularClock()
{
static const clock_t clock = regularClockCheck();
return clock;
}
#endif
bool QElapsedTimer::isMonotonic() noexcept
{
return clockType() == MonotonicClock;
}
QElapsedTimer::ClockType QElapsedTimer::clockType() noexcept
{
return regularClock() == CLOCK_REALTIME ? SystemTime : MonotonicClock;
}
static inline void do_gettime(qint64 *sec, qint64 *frac)
{
timespec ts;
qt_clock_gettime(regularClock(), &ts);
*sec = ts.tv_sec;
*frac = ts.tv_nsec;
}
// used in qcore_unix.cpp and qeventdispatcher_unix.cpp
struct timespec qt_gettime() noexcept
{
qint64 sec, frac;
do_gettime(&sec, &frac);
timespec tv;
tv.tv_sec = sec;
tv.tv_nsec = frac;
return tv;
}
void qt_nanosleep(timespec amount)
{
// We'd like to use clock_nanosleep.
//
// But clock_nanosleep is from POSIX.1-2001 and both are *not*
// affected by clock changes when using relative sleeps, even for
// CLOCK_REALTIME.
//
// nanosleep is POSIX.1-1993
int r;
EINTR_LOOP(r, nanosleep(&amount, &amount));
}
static qint64 elapsedAndRestart(qint64 sec, qint64 frac,
qint64 *nowsec, qint64 *nowfrac)
{
do_gettime(nowsec, nowfrac);
sec = *nowsec - sec;
frac = *nowfrac - frac;
return (sec * Q_INT64_C(1000000000) + frac) / Q_INT64_C(1000000);
}
void QElapsedTimer::start() noexcept
{
do_gettime(&t1, &t2);
}
qint64 QElapsedTimer::restart() noexcept
{
return elapsedAndRestart(t1, t2, &t1, &t2);
}
qint64 QElapsedTimer::nsecsElapsed() const noexcept
{
qint64 sec, frac;
do_gettime(&sec, &frac);
sec = sec - t1;
frac = frac - t2;
return sec * Q_INT64_C(1000000000) + frac;
}
qint64 QElapsedTimer::elapsed() const noexcept
{
return nsecsElapsed() / Q_INT64_C(1000000);
}
qint64 QElapsedTimer::msecsSinceReference() const noexcept
{
return t1 * Q_INT64_C(1000) + t2 / Q_INT64_C(1000000);
}
qint64 QElapsedTimer::msecsTo(const QElapsedTimer &other) const noexcept
{
qint64 secs = other.t1 - t1;
qint64 fraction = other.t2 - t2;
return (secs * Q_INT64_C(1000000000) + fraction) / Q_INT64_C(1000000);
}
qint64 QElapsedTimer::secsTo(const QElapsedTimer &other) const noexcept
{
return other.t1 - t1;
}
bool operator<(const QElapsedTimer &v1, const QElapsedTimer &v2) noexcept
{
return v1.t1 < v2.t1 || (v1.t1 == v2.t1 && v1.t2 < v2.t2);
}
QDeadlineTimer QDeadlineTimer::current(Qt::TimerType timerType) noexcept
{
static_assert(QDeadlineTimerNanosecondsInT2);
QDeadlineTimer result;
qint64 cursec, curnsec;
do_gettime(&cursec, &curnsec);
result.t1 = cursec;
result.t2 = curnsec;
result.type = timerType;
return result;
}
QT_END_NAMESPACE
|
