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_UPTIME_RAW |
118 | #if defined(_LIBCPP_USE_CLOCK_GETTIME) && defined(CLOCK_UPTIME_RAW) |
119 | steady_clock::time_point |
120 | steady_clock::now() _NOEXCEPT |
121 | { |
122 | struct timespec tp; |
123 | if (0 != clock_gettime(CLOCK_UPTIME_RAW, &tp)) |
124 | __throw_system_error(errno, "clock_gettime(CLOCK_UPTIME_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_UPTIME_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 or mach_absolute_time are able to |
210 | // time functions in the nanosecond range. Thus, they are the only acceptable |
211 | // 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 |
234 | |