Coverage Report

Created: 2020-03-31 06:27

/Users/buildslave/jenkins/workspace/coverage/llvm-project/libcxx/src/chrono.cpp
Line
Count
Source (jump to first uncovered line)
1
//===------------------------- chrono.cpp ---------------------------------===//
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
#include "chrono"
10
#include "cerrno"        // errno
11
#include "system_error"  // __throw_system_error
12
#include <time.h>        // clock_gettime, CLOCK_MONOTONIC and CLOCK_REALTIME
13
#include "include/apple_availability.h"
14
15
#if !defined(__APPLE__)
16
#define _LIBCPP_USE_CLOCK_GETTIME
17
#endif // __APPLE__
18
19
#if defined(_LIBCPP_WIN32API)
20
#define WIN32_LEAN_AND_MEAN
21
#define VC_EXTRA_LEAN
22
#include <windows.h>
23
#if _WIN32_WINNT >= _WIN32_WINNT_WIN8
24
#include <winapifamily.h>
25
#endif
26
#else
27
#if !defined(CLOCK_REALTIME) || !defined(_LIBCPP_USE_CLOCK_GETTIME)
28
#include <sys/time.h>        // for gettimeofday and timeval
29
#endif // !defined(CLOCK_REALTIME)
30
#endif // defined(_LIBCPP_WIN32API)
31
32
#if !defined(_LIBCPP_HAS_NO_MONOTONIC_CLOCK)
33
#if __APPLE__
34
#include <mach/mach_time.h>  // mach_absolute_time, mach_timebase_info_data_t
35
#elif !defined(_LIBCPP_WIN32API) && !defined(CLOCK_MONOTONIC)
36
#error "Monotonic clock not implemented"
37
#endif
38
#endif
39
40
#if defined(__ELF__) && defined(_LIBCPP_LINK_RT_LIB)
41
#pragma comment(lib, "rt")
42
#endif
43
44
_LIBCPP_BEGIN_NAMESPACE_STD
45
46
namespace chrono
47
{
48
49
// system_clock
50
51
const bool system_clock::is_steady;
52
53
system_clock::time_point
54
system_clock::now() _NOEXCEPT
55
51
{
56
#if defined(_LIBCPP_WIN32API)
57
  // FILETIME is in 100ns units
58
  using filetime_duration =
59
      _VSTD::chrono::duration<__int64,
60
                              _VSTD::ratio_multiply<_VSTD::ratio<100, 1>,
61
                                                    nanoseconds::period>>;
62
63
  // The Windows epoch is Jan 1 1601, the Unix epoch Jan 1 1970.
64
  static _LIBCPP_CONSTEXPR const seconds nt_to_unix_epoch{11644473600};
65
66
  FILETIME ft;
67
#if _WIN32_WINNT >= _WIN32_WINNT_WIN8
68
#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP)
69
  GetSystemTimePreciseAsFileTime(&ft);
70
#else
71
  GetSystemTimeAsFileTime(&ft);
72
#endif
73
#else
74
  GetSystemTimeAsFileTime(&ft);
75
#endif
76
77
  filetime_duration d{(static_cast<__int64>(ft.dwHighDateTime) << 32) |
78
                       static_cast<__int64>(ft.dwLowDateTime)};
79
  return time_point(duration_cast<duration>(d - nt_to_unix_epoch));
80
#else
81
#if defined(_LIBCPP_USE_CLOCK_GETTIME) && defined(CLOCK_REALTIME)
82
51
  struct timespec tp;
83
51
  if (0 != clock_gettime(CLOCK_REALTIME, &tp))
84
0
    __throw_system_error(errno, "clock_gettime(CLOCK_REALTIME) failed");
85
51
  return time_point(seconds(tp.tv_sec) + microseconds(tp.tv_nsec / 1000));
86
#else
87
    timeval tv;
88
    gettimeofday(&tv, 0);
89
    return time_point(seconds(tv.tv_sec) + microseconds(tv.tv_usec));
90
#endif // _LIBCPP_USE_CLOCK_GETTIME && CLOCK_REALTIME
91
#endif
92
51
}
93
94
time_t
95
system_clock::to_time_t(const time_point& t) _NOEXCEPT
96
56.5k
{
97
56.5k
    return time_t(duration_cast<seconds>(t.time_since_epoch()).count());
98
56.5k
}
99
100
system_clock::time_point
101
system_clock::from_time_t(time_t t) _NOEXCEPT
102
189k
{
103
189k
    return system_clock::time_point(seconds(t));
104
189k
}
105
106
#ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK
107
// steady_clock
108
//
109
// Warning:  If this is not truly steady, then it is non-conforming.  It is
110
//  better for it to not exist and have the rest of libc++ use system_clock
111
//  instead.
112
113
const bool steady_clock::is_steady;
114
115
#if defined(__APPLE__)
116
117
// Darwin libc versions >= 1133 provide ns precision via CLOCK_MONOTONIC_RAW
118
#if defined(_LIBCPP_USE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC_RAW)
119
steady_clock::time_point
120
steady_clock::now() _NOEXCEPT
121
66
{
122
66
    struct timespec tp;
123
66
    if (0 != clock_gettime(CLOCK_MONOTONIC_RAW, &tp))
124
0
        __throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC_RAW) failed");
125
66
    return time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec));
126
66
}
127
128
#else
129
//   mach_absolute_time() * MachInfo.numer / MachInfo.denom is the number of
130
//   nanoseconds since the computer booted up.  MachInfo.numer and MachInfo.denom
131
//   are run time constants supplied by the OS.  This clock has no relationship
132
//   to the Gregorian calendar.  It's main use is as a high resolution timer.
133
134
// MachInfo.numer / MachInfo.denom is often 1 on the latest equipment.  Specialize
135
//   for that case as an optimization.
136
137
static
138
steady_clock::rep
139
steady_simplified()
140
{
141
    return static_cast<steady_clock::rep>(mach_absolute_time());
142
}
143
144
static
145
double
146
compute_steady_factor()
147
{
148
    mach_timebase_info_data_t MachInfo;
149
    mach_timebase_info(&MachInfo);
150
    return static_cast<double>(MachInfo.numer) / MachInfo.denom;
151
}
152
153
static
154
steady_clock::rep
155
steady_full()
156
{
157
    static const double factor = compute_steady_factor();
158
    return static_cast<steady_clock::rep>(mach_absolute_time() * factor);
159
}
160
161
typedef steady_clock::rep (*FP)();
162
163
static
164
FP
165
init_steady_clock()
166
{
167
    mach_timebase_info_data_t MachInfo;
168
    mach_timebase_info(&MachInfo);
169
    if (MachInfo.numer == MachInfo.denom)
170
        return &steady_simplified;
171
    return &steady_full;
172
}
173
174
steady_clock::time_point
175
steady_clock::now() _NOEXCEPT
176
{
177
    static FP fp = init_steady_clock();
178
    return time_point(duration(fp()));
179
}
180
#endif // defined(_LIBCPP_USE_CLOCK_GETTIME) && defined(CLOCK_MONOTONIC_RAW)
181
182
#elif defined(_LIBCPP_WIN32API)
183
184
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms644905(v=vs.85).aspx says:
185
//    If the function fails, the return value is zero. <snip>
186
//    On systems that run Windows XP or later, the function will always succeed
187
//      and will thus never return zero.
188
189
static LARGE_INTEGER
190
__QueryPerformanceFrequency()
191
{
192
  LARGE_INTEGER val;
193
  (void) QueryPerformanceFrequency(&val);
194
  return val;
195
}
196
197
steady_clock::time_point
198
steady_clock::now() _NOEXCEPT
199
{
200
  static const LARGE_INTEGER freq = __QueryPerformanceFrequency();
201
202
  LARGE_INTEGER counter;
203
  (void) QueryPerformanceCounter(&counter);
204
  return time_point(duration(counter.QuadPart * nano::den / freq.QuadPart));
205
}
206
207
#elif defined(CLOCK_MONOTONIC)
208
209
// On Apple platforms only CLOCK_UPTIME_RAW, CLOCK_MONOTONIC_RAW or
210
// mach_absolute_time are able to time functions in the nanosecond range.
211
// Thus, they are the only acceptable implementations of steady_clock.
212
#ifdef __APPLE__
213
#error "Never use CLOCK_MONOTONIC for steady_clock::now on Apple platforms"
214
#endif
215
216
steady_clock::time_point
217
steady_clock::now() _NOEXCEPT
218
{
219
    struct timespec tp;
220
    if (0 != clock_gettime(CLOCK_MONOTONIC, &tp))
221
        __throw_system_error(errno, "clock_gettime(CLOCK_MONOTONIC) failed");
222
    return time_point(seconds(tp.tv_sec) + nanoseconds(tp.tv_nsec));
223
}
224
225
#else
226
#error "Monotonic clock not implemented"
227
#endif
228
229
#endif // !_LIBCPP_HAS_NO_MONOTONIC_CLOCK
230
231
}
232
233
_LIBCPP_END_NAMESPACE_STD