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