[libc++][Apple] Use CLOCK_MONOTONIC_RAW instead of CLOCK_UPTIME_RAW for steady_clock
[lldb.git] / libcxx / src / chrono.cpp
1 //===------------------------- chrono.cpp ---------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "chrono"
10 #include "cerrno"        // errno
11 #include "system_error"  // __throw_system_error
12 #include <time.h>        // clock_gettime, CLOCK_MONOTONIC and CLOCK_REALTIME
13 #include "include/apple_availability.h"
14
15 #if !defined(__APPLE__)
16 #define _LIBCPP_USE_CLOCK_GETTIME
17 #endif // __APPLE__
18
19 #if defined(_LIBCPP_WIN32API)
20 #define WIN32_LEAN_AND_MEAN
21 #define VC_EXTRA_LEAN
22 #include <windows.h>
23 #if _WIN32_WINNT >= _WIN32_WINNT_WIN8
24 #include <winapifamily.h>
25 #endif
26 #else
27 #if !defined(CLOCK_REALTIME) || !defined(_LIBCPP_USE_CLOCK_GETTIME)
28 #include <sys/time.h>        // for gettimeofday and timeval
29 #endif // !defined(CLOCK_REALTIME)
30 #endif // defined(_LIBCPP_WIN32API)
31
32 #if !defined(_LIBCPP_HAS_NO_MONOTONIC_CLOCK)
33 #if __APPLE__
34 #include <mach/mach_time.h>  // mach_absolute_time, mach_timebase_info_data_t
35 #elif !defined(_LIBCPP_WIN32API) && !defined(CLOCK_MONOTONIC)
36 #error "Monotonic clock not implemented"
37 #endif
38 #endif
39
40 #if defined(__ELF__) && defined(_LIBCPP_LINK_RT_LIB)
41 #pragma comment(lib, "rt")
42 #endif
43
44 _LIBCPP_BEGIN_NAMESPACE_STD
45
46 namespace chrono
47 {
48
49 // system_clock
50
51 const bool system_clock::is_steady;
52
53 system_clock::time_point
54 system_clock::now() _NOEXCEPT
55 {
56 #if defined(_LIBCPP_WIN32API)
57   // FILETIME is in 100ns units
58   using filetime_duration =
59       _VSTD::chrono::duration<__int64,
60                               _VSTD::ratio_multiply<_VSTD::ratio<100, 1>,
61                                                     nanoseconds::period>>;
62
63   // The Windows epoch is Jan 1 1601, the Unix epoch Jan 1 1970.
64   static _LIBCPP_CONSTEXPR const seconds nt_to_unix_epoch{11644473600};
65
66   FILETIME ft;
67 #if _WIN32_WINNT >= _WIN32_WINNT_WIN8
68 #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
69   GetSystemTimePreciseAsFileTime(&ft);
70 #else
71   GetSystemTimeAsFileTime(&ft);
72 #endif
73 #else
74   GetSystemTimeAsFileTime(&ft);
75 #endif
76
77   filetime_duration d{(static_cast<__int64>(ft.dwHighDateTime) << 32) |
78                        static_cast<__int64>(ft.dwLowDateTime)};
79   return time_point(duration_cast<duration>(d - nt_to_unix_epoch));
80 #else
81 #if defined(_LIBCPP_USE_CLOCK_GETTIME) && defined(CLOCK_REALTIME)
82   struct timespec tp;
83   if (0 != clock_gettime(CLOCK_REALTIME, &tp))
84     __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
85   return time_point(seconds(tp.tv_sec) + microseconds(tp.tv_nsec / 1000));
86 #else
87     timeval tv;
88     gettimeofday(&tv, 0);
89     return time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
90 #endif // _LIBCPP_USE_CLOCK_GETTIME && CLOCK_REALTIME
91 #endif
92 }
93
94 time_t
95 system_clock::to_time_t(const time_point& t) _NOEXCEPT
96 {
97     return time_t(duration_cast<seconds>(t.time_since_epoch()).count());
98 }
99
100 system_clock::time_point
101 system_clock::from_time_t(time_t t) _NOEXCEPT
102 {
103     return system_clock::time_point(seconds(t));
104 }
105
106 #ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK
107 // steady_clock
108 //
109 // Warning:  If this is not truly steady, then it is non-conforming.  It is
110 //  better for it to not exist and have the rest of libc++ use system_clock
111 //  instead.
112
113 const bool steady_clock::is_steady;
114
115 #if defined(__APPLE__)
116
117 // Darwin libc versions >= 1133 provide ns precision via CLOCK_MONOTONIC_RAW
118 #if defined(_LIBCPP_USE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC_RAW)
119 steady_clock::time_point
120 steady_clock::now() _NOEXCEPT
121 {
122     struct timespec tp;
123     if (0 != clock_gettime(CLOCK_MONOTONIC_RAW, &tp))
124         __throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC_RAW) failed");
125     return time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec));
126 }
127
128 #else
129 //   mach_absolute_time() * MachInfo.numer / MachInfo.denom is the number of
130 //   nanoseconds since the computer booted up.  MachInfo.numer and MachInfo.denom
131 //   are run time constants supplied by the OS.  This clock has no relationship
132 //   to the Gregorian calendar.  It's main use is as a high resolution timer.
133
134 // MachInfo.numer / MachInfo.denom is often 1 on the latest equipment.  Specialize
135 //   for that case as an optimization.
136
137 static
138 steady_clock::rep
139 steady_simplified()
140 {
141     return static_cast<steady_clock::rep>(mach_absolute_time());
142 }
143
144 static
145 double
146 compute_steady_factor()
147 {
148     mach_timebase_info_data_t MachInfo;
149     mach_timebase_info(&MachInfo);
150     return static_cast<double>(MachInfo.numer) / MachInfo.denom;
151 }
152
153 static
154 steady_clock::rep
155 steady_full()
156 {
157     static const double factor = compute_steady_factor();
158     return static_cast<steady_clock::rep>(mach_absolute_time() * factor);
159 }
160
161 typedef steady_clock::rep (*FP)();
162
163 static
164 FP
165 init_steady_clock()
166 {
167     mach_timebase_info_data_t MachInfo;
168     mach_timebase_info(&MachInfo);
169     if (MachInfo.numer == MachInfo.denom)
170         return &steady_simplified;
171     return &steady_full;
172 }
173
174 steady_clock::time_point
175 steady_clock::now() _NOEXCEPT
176 {
177     static FP fp = init_steady_clock();
178     return time_point(duration(fp()));
179 }
180 #endif // defined(_LIBCPP_USE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC_RAW)
181
182 #elif defined(_LIBCPP_WIN32API)
183
184 // https://msdn.microsoft.com/en-us/library/windows/desktop/ms644905(v=vs.85).aspx says:
185 //    If the function fails, the return value is zero. <snip>
186 //    On systems that run Windows XP or later, the function will always succeed
187 //      and will thus never return zero.
188
189 static LARGE_INTEGER
190 __QueryPerformanceFrequency()
191 {
192         LARGE_INTEGER val;
193         (void) QueryPerformanceFrequency(&val);
194         return val;
195 }
196
197 steady_clock::time_point
198 steady_clock::now() _NOEXCEPT
199 {
200   static const LARGE_INTEGER freq = __QueryPerformanceFrequency();
201
202   LARGE_INTEGER counter;
203   (void) QueryPerformanceCounter(&counter);
204   return time_point(duration(counter.QuadPart * nano::den / freq.QuadPart));
205 }
206
207 #elif defined(CLOCK_MONOTONIC)
208
209 // On Apple platforms only CLOCK_UPTIME_RAW, CLOCK_MONOTONIC_RAW or
210 // mach_absolute_time are able to time functions in the nanosecond range.
211 // Thus, they are the only acceptable implementations of steady_clock.
212 #ifdef __APPLE__
213 #error "Never use CLOCK_MONOTONIC for steady_clock::now on Apple platforms"
214 #endif
215
216 steady_clock::time_point
217 steady_clock::now() _NOEXCEPT
218 {
219     struct timespec tp;
220     if (0 != clock_gettime(CLOCK_MONOTONIC, &tp))
221         __throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC) failed");
222     return time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec));
223 }
224
225 #else
226 #error "Monotonic clock not implemented"
227 #endif
228
229 #endif // !_LIBCPP_HAS_NO_MONOTONIC_CLOCK
230
231 }
232
233 _LIBCPP_END_NAMESPACE_STD