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