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(__unix__) && defined(__ELF__) && defined(_LIBCPP_HAS_COMMENT_LIB_PRAGMA) 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