1 //===----------------------------------------------------------------------===//
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 #if defined(__MVS__)
10 // As part of monotonic clock support on z/OS we need macro _LARGE_TIME_API
11 // to be defined before any system header to include definition of struct timespec64.
12 # define _LARGE_TIME_API
13 #endif
14
15 #include <__system_error/throw_system_error.h>
16 #include <cerrno> // errno
17 #include <chrono>
18
19 #if defined(__MVS__)
20 # include <__support/ibm/gettod_zos.h> // gettimeofdayMonotonic
21 #endif
22
23 #include "include/apple_availability.h"
24 #include <time.h> // clock_gettime and CLOCK_{MONOTONIC,REALTIME,MONOTONIC_RAW}
25
26 #if __has_include(<unistd.h>)
27 # include <unistd.h> // _POSIX_TIMERS
28 #endif
29
30 #if __has_include(<sys/time.h>)
31 # include <sys/time.h> // for gettimeofday and timeval
32 #endif
33
34 #if defined(__LLVM_LIBC__)
35 # define _LIBCPP_HAS_TIMESPEC_GET
36 #endif
37
38 // OpenBSD and GPU do not have a fully conformant suite of POSIX timers, but
39 // it does have clock_gettime and CLOCK_MONOTONIC which is all we need.
40 #if defined(__APPLE__) || defined(__gnu_hurd__) || defined(__OpenBSD__) || defined(__AMDGPU__) || \
41 defined(__NVPTX__) || (defined(_POSIX_TIMERS) && _POSIX_TIMERS > 0)
42 # define _LIBCPP_HAS_CLOCK_GETTIME
43 #endif
44
45 #if defined(_LIBCPP_WIN32API)
46 # define WIN32_LEAN_AND_MEAN
47 # define VC_EXTRA_LEAN
48 # include <windows.h>
49 # if _WIN32_WINNT >= _WIN32_WINNT_WIN8
50 # include <winapifamily.h>
51 # endif
52 #endif // defined(_LIBCPP_WIN32API)
53
54 #if defined(__Fuchsia__)
55 # include <zircon/syscalls.h>
56 #endif
57
58 #if __has_include(<mach/mach_time.h>)
59 # include <mach/mach_time.h>
60 #endif
61
62 #if defined(__ELF__) && defined(_LIBCPP_LINK_RT_LIB)
63 # pragma comment(lib, "rt")
64 #endif
65
66 _LIBCPP_BEGIN_NAMESPACE_STD
67
68 namespace chrono {
69
70 //
71 // system_clock
72 //
73
74 #if defined(_LIBCPP_WIN32API)
75
76 # if _WIN32_WINNT < _WIN32_WINNT_WIN8
77
78 namespace {
79
80 typedef void(WINAPI* GetSystemTimeAsFileTimePtr)(LPFILETIME);
81
82 class GetSystemTimeInit {
83 public:
GetSystemTimeInit()84 GetSystemTimeInit() {
85 fp = (GetSystemTimeAsFileTimePtr)(void*)GetProcAddress(
86 GetModuleHandleW(L"kernel32.dll"), "GetSystemTimePreciseAsFileTime");
87 if (fp == nullptr)
88 fp = GetSystemTimeAsFileTime;
89 }
90 GetSystemTimeAsFileTimePtr fp;
91 };
92
93 // Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority
94 // attribute with a value that's reserved for the implementation (we're the implementation).
95 # include "chrono_system_time_init.h"
96 } // namespace
97
98 # endif
99
__libcpp_system_clock_now()100 static system_clock::time_point __libcpp_system_clock_now() {
101 // FILETIME is in 100ns units
102 using filetime_duration =
103 std::chrono::duration<__int64, std::ratio_multiply<std::ratio<100, 1>, nanoseconds::period>>;
104
105 // The Windows epoch is Jan 1 1601, the Unix epoch Jan 1 1970.
106 static constexpr const seconds nt_to_unix_epoch{11644473600};
107
108 FILETIME ft;
109 # if (_WIN32_WINNT >= _WIN32_WINNT_WIN8 && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)) || \
110 (_WIN32_WINNT >= _WIN32_WINNT_WIN10)
111 GetSystemTimePreciseAsFileTime(&ft);
112 # elif !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
113 GetSystemTimeAsFileTime(&ft);
114 # else
115 GetSystemTimeAsFileTimeFunc.fp(&ft);
116 # endif
117
118 filetime_duration d{(static_cast<__int64>(ft.dwHighDateTime) << 32) | static_cast<__int64>(ft.dwLowDateTime)};
119 return system_clock::time_point(duration_cast<system_clock::duration>(d - nt_to_unix_epoch));
120 }
121
122 #elif defined(_LIBCPP_HAS_TIMESPEC_GET)
123
124 static system_clock::time_point __libcpp_system_clock_now() {
125 struct timespec ts;
126 if (timespec_get(&ts, TIME_UTC) != TIME_UTC)
127 std::__throw_system_error(errno, "timespec_get(TIME_UTC) failed");
128 return system_clock::time_point(seconds(ts.tv_sec) + microseconds(ts.tv_nsec / 1000));
129 }
130
131 #elif defined(_LIBCPP_HAS_CLOCK_GETTIME)
132
133 static system_clock::time_point __libcpp_system_clock_now() {
134 struct timespec tp;
135 if (0 != clock_gettime(CLOCK_REALTIME, &tp))
136 std::__throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
137 return system_clock::time_point(seconds(tp.tv_sec) + microseconds(tp.tv_nsec / 1000));
138 }
139
140 #else
141
142 static system_clock::time_point __libcpp_system_clock_now() {
143 timeval tv;
144 gettimeofday(&tv, 0);
145 return system_clock::time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
146 }
147
148 #endif
149
150 _LIBCPP_DIAGNOSTIC_PUSH
151 _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated")
152 const bool system_clock::is_steady;
153 _LIBCPP_DIAGNOSTIC_POP
154
now()155 system_clock::time_point system_clock::now() noexcept { return __libcpp_system_clock_now(); }
156
to_time_t(const time_point & t)157 time_t system_clock::to_time_t(const time_point& t) noexcept {
158 return time_t(duration_cast<seconds>(t.time_since_epoch()).count());
159 }
160
from_time_t(time_t t)161 system_clock::time_point system_clock::from_time_t(time_t t) noexcept { return system_clock::time_point(seconds(t)); }
162
163 //
164 // steady_clock
165 //
166 // Warning: If this is not truly steady, then it is non-conforming. It is
167 // better for it to not exist and have the rest of libc++ use system_clock
168 // instead.
169 //
170
171 #if _LIBCPP_HAS_MONOTONIC_CLOCK
172
173 # if defined(__APPLE__)
174
175 // On Apple platforms, only CLOCK_UPTIME_RAW, CLOCK_MONOTONIC_RAW or
176 // mach_absolute_time are able to time functions in the nanosecond range.
177 // Furthermore, only CLOCK_MONOTONIC_RAW is truly monotonic, because it
178 // also counts cycles when the system is asleep. Thus, it is the only
179 // acceptable implementation of steady_clock.
__libcpp_steady_clock_now()180 static steady_clock::time_point __libcpp_steady_clock_now() {
181 struct timespec tp;
182 if (0 != clock_gettime(CLOCK_MONOTONIC_RAW, &tp))
183 std::__throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC_RAW) failed");
184 return steady_clock::time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec));
185 }
186
187 # elif defined(_LIBCPP_WIN32API)
188
189 // https://msdn.microsoft.com/en-us/library/windows/desktop/ms644905(v=vs.85).aspx says:
190 // If the function fails, the return value is zero. <snip>
191 // On systems that run Windows XP or later, the function will always succeed
192 // and will thus never return zero.
193
__QueryPerformanceFrequency()194 static LARGE_INTEGER __QueryPerformanceFrequency() {
195 LARGE_INTEGER val;
196 (void)QueryPerformanceFrequency(&val);
197 return val;
198 }
199
__libcpp_steady_clock_now()200 static steady_clock::time_point __libcpp_steady_clock_now() {
201 static const LARGE_INTEGER freq = __QueryPerformanceFrequency();
202
203 LARGE_INTEGER counter;
204 (void)QueryPerformanceCounter(&counter);
205 auto seconds = counter.QuadPart / freq.QuadPart;
206 auto fractions = counter.QuadPart % freq.QuadPart;
207 auto dur = seconds * nano::den + fractions * nano::den / freq.QuadPart;
208 return steady_clock::time_point(steady_clock::duration(dur));
209 }
210
211 # elif defined(__MVS__)
212
__libcpp_steady_clock_now()213 static steady_clock::time_point __libcpp_steady_clock_now() {
214 struct timespec64 ts;
215 if (0 != gettimeofdayMonotonic(&ts))
216 std::__throw_system_error(errno, "failed to obtain time of day");
217
218 return steady_clock::time_point(seconds(ts.tv_sec) + nanoseconds(ts.tv_nsec));
219 }
220
221 # elif defined(__Fuchsia__)
222
__libcpp_steady_clock_now()223 static steady_clock::time_point __libcpp_steady_clock_now() noexcept {
224 // Implicitly link against the vDSO system call ABI without
225 // requiring the final link to specify -lzircon explicitly when
226 // statically linking libc++.
227 # pragma comment(lib, "zircon")
228
229 return steady_clock::time_point(nanoseconds(_zx_clock_get_monotonic()));
230 }
231
232 # elif defined(_LIBCPP_HAS_TIMESPEC_GET)
233
__libcpp_steady_clock_now()234 static steady_clock::time_point __libcpp_steady_clock_now() {
235 struct timespec ts;
236 if (timespec_get(&ts, TIME_MONOTONIC) != TIME_MONOTONIC)
237 std::__throw_system_error(errno, "timespec_get(TIME_MONOTONIC) failed");
238 return steady_clock::time_point(seconds(ts.tv_sec) + microseconds(ts.tv_nsec / 1000));
239 }
240
241 # elif defined(_LIBCPP_HAS_CLOCK_GETTIME)
242
__libcpp_steady_clock_now()243 static steady_clock::time_point __libcpp_steady_clock_now() {
244 struct timespec tp;
245 if (0 != clock_gettime(CLOCK_MONOTONIC, &tp))
246 std::__throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC) failed");
247 return steady_clock::time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec));
248 }
249
250 # else
251 # error "Monotonic clock not implemented on this platform"
252 # endif
253
254 _LIBCPP_DIAGNOSTIC_PUSH
255 _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated")
256 const bool steady_clock::is_steady;
257 _LIBCPP_DIAGNOSTIC_POP
258
now()259 steady_clock::time_point steady_clock::now() noexcept { return __libcpp_steady_clock_now(); }
260
261 #endif // _LIBCPP_HAS_MONOTONIC_CLOCK
262
263 } // namespace chrono
264
265 _LIBCPP_END_NAMESPACE_STD
266