libcxx/src/chrono.cpp

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