diff options
author | Andrey Khalyavin <halyavin@gmail.com> | 2022-02-10 16:46:29 +0300 |
---|---|---|
committer | Daniil Cherednik <dcherednik@yandex-team.ru> | 2022-02-10 16:46:29 +0300 |
commit | f773626848a7c7456803654292e716b83d69cc12 (patch) | |
tree | db052dfcf9134f492bdbb962cb6c16cea58e1ed3 /contrib/libs/cxxsupp/libcxx/src/chrono.cpp | |
parent | f43ab775d197d300eb67bd4497632b909cd7c2a5 (diff) | |
download | ydb-f773626848a7c7456803654292e716b83d69cc12.tar.gz |
Restoring authorship annotation for Andrey Khalyavin <halyavin@gmail.com>. Commit 1 of 2.
Diffstat (limited to 'contrib/libs/cxxsupp/libcxx/src/chrono.cpp')
-rw-r--r-- | contrib/libs/cxxsupp/libcxx/src/chrono.cpp | 578 |
1 files changed, 289 insertions, 289 deletions
diff --git a/contrib/libs/cxxsupp/libcxx/src/chrono.cpp b/contrib/libs/cxxsupp/libcxx/src/chrono.cpp index b18e4f7cb9..c2858529f2 100644 --- a/contrib/libs/cxxsupp/libcxx/src/chrono.cpp +++ b/contrib/libs/cxxsupp/libcxx/src/chrono.cpp @@ -1,298 +1,298 @@ -//===------------------------- 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() { +// +//===----------------------------------------------------------------------===// + +#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() -{ + 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 +} + +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 |