1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim:set ts=2 sw=2 sts=2 et cindent: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
8 // Implement TimeStamp::Now() with POSIX clocks.
10 // The "tick" unit for POSIX clocks is simply a nanosecond, as this is
11 // the smallest unit of time representable by struct timespec. That
12 // doesn't mean that a nanosecond is the resolution of TimeDurations
13 // obtained with this API; see TimeDuration::Resolution;
16 #include <sys/syscall.h>
20 #if defined(__DragonFly__) || defined(__FreeBSD__) \
21 || defined(__NetBSD__) || defined(__OpenBSD__)
22 #include <sys/param.h>
23 #include <sys/sysctl.h>
26 #if defined(__DragonFly__) || defined(__FreeBSD__)
30 #if defined(__NetBSD__)
32 #define KERN_PROC KERN_PROC2
33 #define KINFO_PROC struct kinfo_proc2
35 #define KINFO_PROC struct kinfo_proc
38 #if defined(__DragonFly__)
39 #define KP_START_SEC kp_start.tv_sec
40 #define KP_START_USEC kp_start.tv_usec
41 #elif defined(__FreeBSD__)
42 #define KP_START_SEC ki_start.tv_sec
43 #define KP_START_USEC ki_start.tv_usec
45 #define KP_START_SEC p_ustart_sec
46 #define KP_START_USEC p_ustart_usec
49 #include "mozilla/TimeStamp.h"
55 // Estimate of the smallest duration of time we can measure.
56 static uint64_t sResolution
;
57 static uint64_t sResolutionSigDigs
;
59 static const uint16_t kNsPerUs
= 1000;
60 static const uint64_t kNsPerMs
= 1000000;
61 static const uint64_t kNsPerSec
= 1000000000;
62 static const double kNsPerMsd
= 1000000.0;
63 static const double kNsPerSecd
= 1000000000.0;
66 TimespecToNs(const struct timespec
& aTs
)
68 uint64_t baseNs
= uint64_t(aTs
.tv_sec
) * kNsPerSec
;
69 return baseNs
+ uint64_t(aTs
.tv_nsec
);
76 // this can't fail: we know &ts is valid, and TimeStamp::Startup()
77 // checks that CLOCK_MONOTONIC is supported (and aborts if not)
78 clock_gettime(CLOCK_MONOTONIC
, &ts
);
80 // tv_sec is defined to be relative to an arbitrary point in time,
81 // but it would be madness for that point in time to be earlier than
82 // the Epoch. So we can safely assume that even if time_t is 32
83 // bits, tv_sec won't overflow while the browser is open. Revisit
84 // this argument if we're still building with 32-bit time_t around
86 return TimespecToNs(ts
);
92 // NB: why not rely on clock_getres()? Two reasons: (i) it might
93 // lie, and (ii) it might return an "ideal" resolution that while
94 // theoretically true, could never be measured in practice. Since
95 // clock_gettime() likely involves a system call on your platform,
96 // the "actual" timing resolution shouldn't be lower than syscall
99 uint64_t start
= ClockTimeNs();
100 uint64_t end
= ClockTimeNs();
101 uint64_t minres
= (end
- start
);
103 // 10 total trials is arbitrary: what we're trying to avoid by
104 // looping is getting unlucky and being interrupted by a context
105 // switch or signal, or being bitten by paging/cache effects
106 for (int i
= 0; i
< 9; ++i
) {
107 start
= ClockTimeNs();
110 uint64_t candidate
= (start
- end
);
111 if (candidate
< minres
) {
117 // measurable resolution is either incredibly low, ~1ns, or very
118 // high. fall back on clock_getres()
120 if (0 == clock_getres(CLOCK_MONOTONIC
, &ts
)) {
121 minres
= TimespecToNs(ts
);
126 // clock_getres probably failed. fall back on NSPR's resolution
128 minres
= 1 * kNsPerMs
;
137 BaseTimeDurationPlatformUtils::ToSeconds(int64_t aTicks
)
139 return double(aTicks
) / kNsPerSecd
;
143 BaseTimeDurationPlatformUtils::ToSecondsSigDigits(int64_t aTicks
)
145 // don't report a value < mResolution ...
146 int64_t valueSigDigs
= sResolution
* (aTicks
/ sResolution
);
147 // and chop off insignificant digits
148 valueSigDigs
= sResolutionSigDigs
* (valueSigDigs
/ sResolutionSigDigs
);
149 return double(valueSigDigs
) / kNsPerSecd
;
153 BaseTimeDurationPlatformUtils::TicksFromMilliseconds(double aMilliseconds
)
155 double result
= aMilliseconds
* kNsPerMsd
;
156 if (result
> INT64_MAX
) {
158 } else if (result
< INT64_MIN
) {
166 BaseTimeDurationPlatformUtils::ResolutionInTicks()
168 return static_cast<int64_t>(sResolution
);
171 static bool gInitialized
= false;
180 struct timespec dummy
;
181 if (clock_gettime(CLOCK_MONOTONIC
, &dummy
) != 0) {
182 NS_RUNTIMEABORT("CLOCK_MONOTONIC is absent!");
185 sResolution
= ClockResolutionNs();
187 // find the number of significant digits in sResolution, for the
188 // sake of ToSecondsSigDigits()
189 for (sResolutionSigDigs
= 1;
190 !(sResolutionSigDigs
== sResolution
||
191 10 * sResolutionSigDigs
> sResolution
);
192 sResolutionSigDigs
*= 10);
200 TimeStamp::Shutdown()
205 TimeStamp::Now(bool aHighResolution
)
207 return TimeStamp(ClockTimeNs());
210 #if defined(LINUX) || defined(ANDROID)
212 // Calculates the amount of jiffies that have elapsed since boot and up to the
213 // starttime value of a specific process as found in its /proc/*/stat file.
214 // Returns 0 if an error occurred.
217 JiffiesSinceBoot(const char* aFile
)
221 FILE* f
= fopen(aFile
, "r");
226 int n
= fread(&stat
, 1, sizeof(stat
) - 1, f
);
236 long long unsigned startTime
= 0; // instead of uint64_t to keep GCC quiet
237 char* s
= strrchr(stat
, ')');
243 int rv
= sscanf(s
+ 2,
244 "%*c %*d %*d %*d %*d %*d %*u %*u %*u %*u "
245 "%*u %*u %*u %*d %*d %*d %*d %*d %*d %llu",
248 if (rv
!= 1 || !startTime
) {
255 // Computes the interval that has elapsed between the thread creation and the
256 // process creation by comparing the starttime fields in the respective
257 // /proc/*/stat files. The resulting value will be a good approximation of the
258 // process uptime. This value will be stored at the address pointed by aTime;
259 // if an error occurred 0 will be stored instead.
262 ComputeProcessUptimeThread(void* aTime
)
264 uint64_t* uptime
= static_cast<uint64_t*>(aTime
);
265 long hz
= sysconf(_SC_CLK_TCK
);
274 sprintf(threadStat
, "/proc/self/task/%d/stat", (pid_t
)syscall(__NR_gettid
));
276 uint64_t threadJiffies
= JiffiesSinceBoot(threadStat
);
277 uint64_t selfJiffies
= JiffiesSinceBoot("/proc/self/stat");
279 if (!threadJiffies
|| !selfJiffies
) {
283 *uptime
= ((threadJiffies
- selfJiffies
) * kNsPerSec
) / hz
;
286 // Computes and returns the process uptime in us on Linux & its derivatives.
287 // Returns 0 if an error was encountered.
290 TimeStamp::ComputeProcessUptime()
293 PRThread
* thread
= PR_CreateThread(PR_USER_THREAD
,
294 ComputeProcessUptimeThread
,
301 PR_JoinThread(thread
);
303 return uptime
/ kNsPerUs
;
306 #elif defined(__DragonFly__) || defined(__FreeBSD__) \
307 || defined(__NetBSD__) || defined(__OpenBSD__)
309 // Computes and returns the process uptime in us on various BSD flavors.
310 // Returns 0 if an error was encountered.
313 TimeStamp::ComputeProcessUptime()
316 int rv
= clock_gettime(CLOCK_REALTIME
, &ts
);
327 #if defined(__NetBSD__) || defined(__OpenBSD__)
332 u_int mibLen
= sizeof(mib
) / sizeof(mib
[0]);
335 size_t bufferSize
= sizeof(proc
);
336 rv
= sysctl(mib
, mibLen
, &proc
, &bufferSize
, nullptr, 0);
342 uint64_t startTime
= ((uint64_t)proc
.KP_START_SEC
* kNsPerSec
) +
343 (proc
.KP_START_USEC
* kNsPerUs
);
344 uint64_t now
= ((uint64_t)ts
.tv_sec
* kNsPerSec
) + ts
.tv_nsec
;
346 if (startTime
> now
) {
350 return (now
- startTime
) / kNsPerUs
;
356 TimeStamp::ComputeProcessUptime()
363 } // namespace mozilla