aboutsummaryrefslogtreecommitdiffstats
path: root/contrib/libs/cxxsupp/libcxx/src/chrono.cpp
diff options
context:
space:
mode:
authorAndrey Khalyavin <halyavin@gmail.com>2022-02-10 16:46:29 +0300
committerDaniil Cherednik <dcherednik@yandex-team.ru>2022-02-10 16:46:29 +0300
commitf773626848a7c7456803654292e716b83d69cc12 (patch)
treedb052dfcf9134f492bdbb962cb6c16cea58e1ed3 /contrib/libs/cxxsupp/libcxx/src/chrono.cpp
parentf43ab775d197d300eb67bd4497632b909cd7c2a5 (diff)
downloadydb-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.cpp578
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