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