path: root/contrib/libs/cxxsupp/libcxx/src/chrono.cpp

//===------------------------- chrono.cpp ---------------------------------===// 
// 
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// 
//===----------------------------------------------------------------------===// 
 
#if defined(__MVS__) 
// As part of monotonic clock support on z/OS we need macro _LARGE_TIME_API 
// to be defined before any system header to include definition of struct timespec64. 
#define _LARGE_TIME_API 
#endif 
 
#include "chrono" 
#include "cerrno"        // errno 
#include "system_error"  // __throw_system_error 
 
#if defined(__MVS__) 
#include <__support/ibm/gettod_zos.h> // gettimeofdayMonotonic 
#endif 
 
#include <time.h>        // clock_gettime and CLOCK_{MONOTONIC,REALTIME,MONOTONIC_RAW} 
#include "include/apple_availability.h" 
 
#if __has_include(<unistd.h>) 
# include <unistd.h> 
#endif 
 
#if __has_include(<sys/time.h>) 
# include <sys/time.h> // for gettimeofday and timeval 
#endif 
 
#if !defined(__APPLE__) && defined(_POSIX_TIMERS) && _POSIX_TIMERS > 0 
# define _LIBCPP_USE_CLOCK_GETTIME 
#endif 
 
#if defined(_LIBCPP_WIN32API) 
#  define WIN32_LEAN_AND_MEAN 
#  define VC_EXTRA_LEAN 
#  include <windows.h> 
#  if _WIN32_WINNT >= _WIN32_WINNT_WIN8 
#    include <winapifamily.h> 
#  endif 
#endif // defined(_LIBCPP_WIN32API) 
 
#if __has_include(<mach/mach_time.h>) 
# include <mach/mach_time.h> 
#endif 
 
#if defined(__ELF__) && defined(_LIBCPP_LINK_RT_LIB) 
#  pragma comment(lib, "rt") 
#endif 
 
_LIBCPP_BEGIN_NAMESPACE_STD 
 
namespace chrono 
{ 
 
// 
// system_clock 
// 
 
#if defined(_LIBCPP_WIN32API) 
 
#if _WIN32_WINNT < _WIN32_WINNT_WIN8 
 
namespace { 
 
typedef void(WINAPI *GetSystemTimeAsFileTimePtr)(LPFILETIME); 
 
class GetSystemTimeInit { 
public: 
  GetSystemTimeInit() { 
    fp = (GetSystemTimeAsFileTimePtr)GetProcAddress( 
        GetModuleHandleW(L"kernel32.dll"), "GetSystemTimePreciseAsFileTime"); 
    if (fp == nullptr) 
      fp = GetSystemTimeAsFileTime; 
  } 
  GetSystemTimeAsFileTimePtr fp; 
}; 
 
#ifndef _LIBCPP_COMPILER_MSVC 
# 83 "chrono.cpp" 1 3 
#endif 
GetSystemTimeInit GetSystemTimeAsFileTimeFunc _LIBCPP_INIT_PRIORITY_MAX; 
#ifndef _LIBCPP_COMPILER_MSVC 
# 85 "chrono.cpp" 2 
#endif 
} // namespace 
 
#endif 
 
static system_clock::time_point __libcpp_system_clock_now() { 
  // FILETIME is in 100ns units 
  using filetime_duration = 
      _VSTD::chrono::duration<__int64, 
                              _VSTD::ratio_multiply<_VSTD::ratio<100, 1>, 
                                                    nanoseconds::period>>; 
 
  // The Windows epoch is Jan 1 1601, the Unix epoch Jan 1 1970. 
  static _LIBCPP_CONSTEXPR const seconds nt_to_unix_epoch{11644473600}; 
 
  FILETIME ft; 
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8 && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)) || \ 
    (_WIN32_WINNT >= _WIN32_WINNT_WIN10) 
  GetSystemTimePreciseAsFileTime(&ft); 
#elif !WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) 
  GetSystemTimeAsFileTime(&ft); 
#else 
  GetSystemTimeAsFileTimeFunc.fp(&ft); 
#endif 
 
  filetime_duration d{(static_cast<__int64>(ft.dwHighDateTime) << 32) | 
                       static_cast<__int64>(ft.dwLowDateTime)}; 
  return system_clock::time_point(duration_cast<system_clock::duration>(d - nt_to_unix_epoch)); 
} 
 
#elif defined(CLOCK_REALTIME) && defined(_LIBCPP_USE_CLOCK_GETTIME) 
 
static system_clock::time_point __libcpp_system_clock_now() { 
  struct timespec tp;
  if (0 != clock_gettime(CLOCK_REALTIME, &tp))
    __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
  return system_clock::time_point(seconds(tp.tv_sec) + microseconds(tp.tv_nsec / 1000)); 
} 
 
#else 
 
static system_clock::time_point __libcpp_system_clock_now() { 
    timeval tv; 
    gettimeofday(&tv, 0); 
    return system_clock::time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec)); 
} 
 
#endif 
 
const bool system_clock::is_steady; 
 
system_clock::time_point 
system_clock::now() noexcept 
{ 
    return __libcpp_system_clock_now(); 
} 
 
time_t 
system_clock::to_time_t(const time_point& t) noexcept 
{ 
    return time_t(duration_cast<seconds>(t.time_since_epoch()).count()); 
} 
 
system_clock::time_point 
system_clock::from_time_t(time_t t) noexcept 
{ 
    return system_clock::time_point(seconds(t)); 
} 
 
// 
// steady_clock 
// 
// Warning:  If this is not truly steady, then it is non-conforming.  It is 
//  better for it to not exist and have the rest of libc++ use system_clock 
//  instead. 
// 
 
#ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK 
 
#if defined(__APPLE__) 
 
// TODO(ldionne): 
// This old implementation of steady_clock is retained until Chrome drops supports 
// for macOS < 10.12. The issue is that they link libc++ statically into their 
// application, which means that libc++ must support being built for such deployment 
// targets. See https://llvm.org/D74489 for details. 
#if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101200) || \ 
    (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 100000) || \ 
    (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 100000) || \ 
    (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 30000) 
# define _LIBCPP_USE_OLD_MACH_ABSOLUTE_TIME 
#endif 
 
#if defined(_LIBCPP_USE_OLD_MACH_ABSOLUTE_TIME) 
 
//   mach_absolute_time() * MachInfo.numer / MachInfo.denom is the number of 
//   nanoseconds since the computer booted up.  MachInfo.numer and MachInfo.denom 
//   are run time constants supplied by the OS.  This clock has no relationship 
//   to the Gregorian calendar.  It's main use is as a high resolution timer. 
 
// MachInfo.numer / MachInfo.denom is often 1 on the latest equipment.  Specialize 
//   for that case as an optimization. 
 
static steady_clock::rep steady_simplified() { 
    return static_cast<steady_clock::rep>(mach_absolute_time()); 
} 
static double compute_steady_factor() { 
    mach_timebase_info_data_t MachInfo; 
    mach_timebase_info(&MachInfo); 
    return static_cast<double>(MachInfo.numer) / MachInfo.denom; 
} 
 
static steady_clock::rep steady_full() { 
    static const double factor = compute_steady_factor(); 
    return static_cast<steady_clock::rep>(mach_absolute_time() * factor); 
} 
 
typedef steady_clock::rep (*FP)(); 
 
static FP init_steady_clock() { 
    mach_timebase_info_data_t MachInfo; 
    mach_timebase_info(&MachInfo); 
    if (MachInfo.numer == MachInfo.denom) 
        return &steady_simplified; 
    return &steady_full; 
} 
 
static steady_clock::time_point __libcpp_steady_clock_now() { 
    static FP fp = init_steady_clock(); 
    return steady_clock::time_point(steady_clock::duration(fp())); 
} 
 
#else // vvvvv default behavior for Apple platforms  vvvvv 
 
// On Apple platforms, only CLOCK_UPTIME_RAW, CLOCK_MONOTONIC_RAW or 
// mach_absolute_time are able to time functions in the nanosecond range. 
// Furthermore, only CLOCK_MONOTONIC_RAW is truly monotonic, because it 
// also counts cycles when the system is asleep. Thus, it is the only 
// acceptable implementation of steady_clock. 
static steady_clock::time_point __libcpp_steady_clock_now() { 
    struct timespec tp; 
    if (0 != clock_gettime(CLOCK_MONOTONIC_RAW, &tp)) 
        __throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC_RAW) failed"); 
    return steady_clock::time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec)); 
} 
 
#endif 
 
#elif defined(_LIBCPP_WIN32API) 
 
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms644905(v=vs.85).aspx says: 
//    If the function fails, the return value is zero. <snip> 
//    On systems that run Windows XP or later, the function will always succeed 
//      and will thus never return zero. 
 
static LARGE_INTEGER 
__QueryPerformanceFrequency() 
{ 
    LARGE_INTEGER val;
    (void) QueryPerformanceFrequency(&val);
    return val;
} 
 
static steady_clock::time_point __libcpp_steady_clock_now() { 
  static const LARGE_INTEGER freq = __QueryPerformanceFrequency(); 
 
  LARGE_INTEGER counter; 
  (void) QueryPerformanceCounter(&counter); 
  auto seconds = counter.QuadPart / freq.QuadPart; 
  auto fractions = counter.QuadPart % freq.QuadPart; 
  auto dur = seconds * nano::den + fractions * nano::den / freq.QuadPart; 
  return steady_clock::time_point(steady_clock::duration(dur)); 
} 
 
#elif defined(__MVS__) 
 
static steady_clock::time_point __libcpp_steady_clock_now() { 
  struct timespec64 ts; 
  if (0 != gettimeofdayMonotonic(&ts)) 
    __throw_system_error(errno, "failed to obtain time of day"); 
 
  return steady_clock::time_point(seconds(ts.tv_sec) + nanoseconds(ts.tv_nsec)); 
} 
 
#elif defined(CLOCK_MONOTONIC) 
 
static steady_clock::time_point __libcpp_steady_clock_now() { 
    struct timespec tp; 
    if (0 != clock_gettime(CLOCK_MONOTONIC, &tp)) 
        __throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC) failed"); 
    return steady_clock::time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec)); 
} 
 
#else 
#   error "Monotonic clock not implemented on this platform" 
#endif 
 
const bool steady_clock::is_steady; 
 
steady_clock::time_point 
steady_clock::now() noexcept 
{ 
    return __libcpp_steady_clock_now(); 
} 
 
#endif // !_LIBCPP_HAS_NO_MONOTONIC_CLOCK 
 
} 
 
_LIBCPP_END_NAMESPACE_STD