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/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 <time.h> // clock_gettime and CLOCK_{MONOTONIC,REALTIME,MONOTONIC_RAW} 24 #include "include/apple_availability.h" 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(__APPLE__) || defined (__gnu_hurd__) || (defined(_POSIX_TIMERS) && _POSIX_TIMERS > 0) 35 # define _LIBCPP_HAS_CLOCK_GETTIME 36 #endif 37 38 #if defined(_LIBCPP_WIN32API) 39 # define WIN32_LEAN_AND_MEAN 40 # define VC_EXTRA_LEAN 41 # include <windows.h> 42 # if _WIN32_WINNT >= _WIN32_WINNT_WIN8 43 # include <winapifamily.h> 44 # endif 45 #endif // defined(_LIBCPP_WIN32API) 46 47 #if defined(__Fuchsia__) 48 # include <zircon/syscalls.h> 49 #endif 50 51 #if __has_include(<mach/mach_time.h>) 52 # include <mach/mach_time.h> 53 #endif 54 55 #if defined(__ELF__) && defined(_LIBCPP_LINK_RT_LIB) 56 # pragma comment(lib, "rt") 57 #endif 58 59 _LIBCPP_BEGIN_NAMESPACE_STD 60 61 namespace chrono 62 { 63 64 // 65 // system_clock 66 // 67 68 #if defined(_LIBCPP_WIN32API) 69 70 #if _WIN32_WINNT < _WIN32_WINNT_WIN8 71 72 namespace { 73 74 typedef void(WINAPI *GetSystemTimeAsFileTimePtr)(LPFILETIME); 75 76 class GetSystemTimeInit { 77 public: 78 GetSystemTimeInit() { 79 fp = (GetSystemTimeAsFileTimePtr)GetProcAddress( 80 GetModuleHandleW(L"kernel32.dll"), "GetSystemTimePreciseAsFileTime"); 81 if (fp == nullptr) 82 fp = GetSystemTimeAsFileTime; 83 } 84 GetSystemTimeAsFileTimePtr fp; 85 }; 86 87 // Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority 88 // attribute with a value that's reserved for the implementation (we're the implementation). 89 #include "chrono_system_time_init.h" 90 } // namespace 91 92 #endif 93 94 static system_clock::time_point __libcpp_system_clock_now() { 95 // FILETIME is in 100ns units 96 using filetime_duration = 97 _VSTD::chrono::duration<__int64, 98 _VSTD::ratio_multiply<_VSTD::ratio<100, 1>, 99 nanoseconds::period>>; 100 101 // The Windows epoch is Jan 1 1601, the Unix epoch Jan 1 1970. 102 static _LIBCPP_CONSTEXPR const seconds nt_to_unix_epoch{11644473600}; 103 104 FILETIME ft; 105 #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8 && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)) || \ 106 (_WIN32_WINNT >= _WIN32_WINNT_WIN10) 107 GetSystemTimePreciseAsFileTime(&ft); 108 #elif !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) 109 GetSystemTimeAsFileTime(&ft); 110 #else 111 GetSystemTimeAsFileTimeFunc.fp(&ft); 112 #endif 113 114 filetime_duration d{(static_cast<__int64>(ft.dwHighDateTime) << 32) | 115 static_cast<__int64>(ft.dwLowDateTime)}; 116 return system_clock::time_point(duration_cast<system_clock::duration>(d - nt_to_unix_epoch)); 117 } 118 119 #elif defined(_LIBCPP_HAS_CLOCK_GETTIME) 120 121 static system_clock::time_point __libcpp_system_clock_now() { 122 struct timespec tp; 123 if (0 != clock_gettime(CLOCK_REALTIME, &tp)) 124 __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed"); 125 return system_clock::time_point(seconds(tp.tv_sec) + microseconds(tp.tv_nsec / 1000)); 126 } 127 128 #else 129 130 static system_clock::time_point __libcpp_system_clock_now() { 131 timeval tv; 132 gettimeofday(&tv, 0); 133 return system_clock::time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec)); 134 } 135 136 #endif 137 138 const bool system_clock::is_steady; 139 140 system_clock::time_point 141 system_clock::now() noexcept 142 { 143 return __libcpp_system_clock_now(); 144 } 145 146 time_t 147 system_clock::to_time_t(const time_point& t) noexcept 148 { 149 return time_t(duration_cast<seconds>(t.time_since_epoch()).count()); 150 } 151 152 system_clock::time_point 153 system_clock::from_time_t(time_t t) noexcept 154 { 155 return system_clock::time_point(seconds(t)); 156 } 157 158 // 159 // steady_clock 160 // 161 // Warning: If this is not truly steady, then it is non-conforming. It is 162 // better for it to not exist and have the rest of libc++ use system_clock 163 // instead. 164 // 165 166 #ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK 167 168 #if defined(__APPLE__) 169 170 // On Apple platforms, only CLOCK_UPTIME_RAW, CLOCK_MONOTONIC_RAW or 171 // mach_absolute_time are able to time functions in the nanosecond range. 172 // Furthermore, only CLOCK_MONOTONIC_RAW is truly monotonic, because it 173 // also counts cycles when the system is asleep. Thus, it is the only 174 // acceptable implementation of steady_clock. 175 static steady_clock::time_point __libcpp_steady_clock_now() { 176 struct timespec tp; 177 if (0 != clock_gettime(CLOCK_MONOTONIC_RAW, &tp)) 178 __throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC_RAW) failed"); 179 return steady_clock::time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec)); 180 } 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 static steady_clock::time_point __libcpp_steady_clock_now() { 198 static const LARGE_INTEGER freq = __QueryPerformanceFrequency(); 199 200 LARGE_INTEGER counter; 201 (void) QueryPerformanceCounter(&counter); 202 auto seconds = counter.QuadPart / freq.QuadPart; 203 auto fractions = counter.QuadPart % freq.QuadPart; 204 auto dur = seconds * nano::den + fractions * nano::den / freq.QuadPart; 205 return steady_clock::time_point(steady_clock::duration(dur)); 206 } 207 208 #elif defined(__MVS__) 209 210 static steady_clock::time_point __libcpp_steady_clock_now() { 211 struct timespec64 ts; 212 if (0 != gettimeofdayMonotonic(&ts)) 213 __throw_system_error(errno, "failed to obtain time of day"); 214 215 return steady_clock::time_point(seconds(ts.tv_sec) + nanoseconds(ts.tv_nsec)); 216 } 217 218 # elif defined(__Fuchsia__) 219 220 static steady_clock::time_point __libcpp_steady_clock_now() noexcept { 221 // Implicitly link against the vDSO system call ABI without 222 // requiring the final link to specify -lzircon explicitly when 223 // statically linking libc++. 224 # pragma comment(lib, "zircon") 225 226 return steady_clock::time_point(nanoseconds(_zx_clock_get_monotonic())); 227 } 228 229 # elif defined(_LIBCPP_HAS_CLOCK_GETTIME) 230 231 static steady_clock::time_point __libcpp_steady_clock_now() { 232 struct timespec tp; 233 if (0 != clock_gettime(CLOCK_MONOTONIC, &tp)) 234 __throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC) failed"); 235 return steady_clock::time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec)); 236 } 237 238 # else 239 # error "Monotonic clock not implemented on this platform" 240 # endif 241 242 const bool steady_clock::is_steady; 243 244 steady_clock::time_point 245 steady_clock::now() noexcept 246 { 247 return __libcpp_steady_clock_now(); 248 } 249 250 #endif // !_LIBCPP_HAS_NO_MONOTONIC_CLOCK 251 252 } 253 254 _LIBCPP_END_NAMESPACE_STD 255