mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
c668976a1d
Now that the implementation of a number of TimeDuration methods have been delegated to a separate TimeDurationPlatformUtils class, it is easier to add consistent handling to the parameters passed to and from those methods. This patch adds checks when converting between TimeDurations and doubles so that Forever (represented by a tick count of INT64_MAX) is paired with PositiveInfinity, and INT64_MIN is paired with NegativeInfinity.
470 lines
15 KiB
C++
470 lines
15 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim:set ts=2 sw=2 sts=2 et cindent: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef mozilla_TimeStamp_h
|
|
#define mozilla_TimeStamp_h
|
|
|
|
#include <stdint.h>
|
|
#include "mozilla/Assertions.h"
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/FloatingPoint.h"
|
|
#include "nscore.h"
|
|
#include "nsDebug.h"
|
|
|
|
namespace IPC {
|
|
template<typename T> struct ParamTraits;
|
|
}
|
|
|
|
#ifdef XP_WIN
|
|
// defines TimeStampValue as a complex value keeping both
|
|
// GetTickCount and QueryPerformanceCounter values
|
|
#include "TimeStamp_windows.h"
|
|
#endif
|
|
|
|
namespace mozilla {
|
|
|
|
#ifndef XP_WIN
|
|
typedef uint64_t TimeStampValue;
|
|
#endif
|
|
|
|
class TimeStamp;
|
|
|
|
/**
|
|
* Platform-specific implementation details of TimeDuration.
|
|
*/
|
|
class TimeDurationPlatformUtils
|
|
{
|
|
public:
|
|
static double ToSeconds(int64_t aTicks);
|
|
static double ToSecondsSigDigits(int64_t aTicks);
|
|
static int64_t TicksFromMilliseconds(double aMilliseconds);
|
|
static int64_t ResolutionInTicks();
|
|
};
|
|
|
|
/**
|
|
* Instances of this class represent the length of an interval of time.
|
|
* Negative durations are allowed, meaning the end is before the start.
|
|
*
|
|
* Internally the duration is stored as a int64_t in units of
|
|
* PR_TicksPerSecond() when building with NSPR interval timers, or a
|
|
* system-dependent unit when building with system clocks. The
|
|
* system-dependent unit must be constant, otherwise the semantics of
|
|
* this class would be broken.
|
|
*/
|
|
class TimeDuration
|
|
{
|
|
public:
|
|
// The default duration is 0.
|
|
MOZ_CONSTEXPR TimeDuration() : mValue(0) {}
|
|
// Allow construction using '0' as the initial value, for readability,
|
|
// but no other numbers (so we don't have any implicit unit conversions).
|
|
struct _SomethingVeryRandomHere;
|
|
MOZ_IMPLICIT TimeDuration(_SomethingVeryRandomHere* aZero) : mValue(0)
|
|
{
|
|
MOZ_ASSERT(!aZero, "Who's playing funny games here?");
|
|
}
|
|
// Default copy-constructor and assignment are OK
|
|
|
|
double ToSeconds() const
|
|
{
|
|
if (mValue == INT64_MAX) {
|
|
return PositiveInfinity<double>();
|
|
}
|
|
if (mValue == INT64_MIN) {
|
|
return NegativeInfinity<double>();
|
|
}
|
|
return TimeDurationPlatformUtils::ToSeconds(mValue);
|
|
}
|
|
// Return a duration value that includes digits of time we think to
|
|
// be significant. This method should be used when displaying a
|
|
// time to humans.
|
|
double ToSecondsSigDigits() const
|
|
{
|
|
if (mValue == INT64_MAX) {
|
|
return PositiveInfinity<double>();
|
|
}
|
|
if (mValue == INT64_MIN) {
|
|
return NegativeInfinity<double>();
|
|
}
|
|
return TimeDurationPlatformUtils::ToSecondsSigDigits(mValue);
|
|
}
|
|
double ToMilliseconds() const { return ToSeconds() * 1000.0; }
|
|
double ToMicroseconds() const { return ToMilliseconds() * 1000.0; }
|
|
|
|
// Using a double here is safe enough; with 53 bits we can represent
|
|
// durations up to over 280,000 years exactly. If the units of
|
|
// mValue do not allow us to represent durations of that length,
|
|
// long durations are clamped to the max/min representable value
|
|
// instead of overflowing.
|
|
static inline TimeDuration FromSeconds(double aSeconds)
|
|
{
|
|
return FromMilliseconds(aSeconds * 1000.0);
|
|
}
|
|
static TimeDuration FromMilliseconds(double aMilliseconds)
|
|
{
|
|
if (aMilliseconds == PositiveInfinity<double>()) {
|
|
return Forever();
|
|
}
|
|
if (aMilliseconds == NegativeInfinity<double>()) {
|
|
return FromTicks(INT64_MIN);
|
|
}
|
|
return FromTicks(
|
|
TimeDurationPlatformUtils::TicksFromMilliseconds(aMilliseconds));
|
|
}
|
|
static inline TimeDuration FromMicroseconds(double aMicroseconds)
|
|
{
|
|
return FromMilliseconds(aMicroseconds / 1000.0);
|
|
}
|
|
|
|
static TimeDuration Forever()
|
|
{
|
|
return FromTicks(INT64_MAX);
|
|
}
|
|
|
|
TimeDuration operator+(const TimeDuration& aOther) const
|
|
{
|
|
return TimeDuration::FromTicks(mValue + aOther.mValue);
|
|
}
|
|
TimeDuration operator-(const TimeDuration& aOther) const
|
|
{
|
|
return TimeDuration::FromTicks(mValue - aOther.mValue);
|
|
}
|
|
TimeDuration& operator+=(const TimeDuration& aOther)
|
|
{
|
|
mValue += aOther.mValue;
|
|
return *this;
|
|
}
|
|
TimeDuration& operator-=(const TimeDuration& aOther)
|
|
{
|
|
mValue -= aOther.mValue;
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
// Block double multiplier (slower, imprecise if long duration) - Bug 853398.
|
|
// If required, use MultDouble explicitly and with care.
|
|
TimeDuration operator*(const double aMultiplier) const MOZ_DELETE;
|
|
|
|
public:
|
|
TimeDuration MultDouble(double aMultiplier) const
|
|
{
|
|
return TimeDuration::FromTicks(static_cast<int64_t>(mValue * aMultiplier));
|
|
}
|
|
TimeDuration operator*(const int32_t aMultiplier) const
|
|
{
|
|
return TimeDuration::FromTicks(mValue * int64_t(aMultiplier));
|
|
}
|
|
TimeDuration operator*(const uint32_t aMultiplier) const
|
|
{
|
|
return TimeDuration::FromTicks(mValue * int64_t(aMultiplier));
|
|
}
|
|
TimeDuration operator*(const int64_t aMultiplier) const
|
|
{
|
|
return TimeDuration::FromTicks(mValue * aMultiplier);
|
|
}
|
|
TimeDuration operator*(const uint64_t aMultiplier) const
|
|
{
|
|
if (aMultiplier > INT64_MAX) {
|
|
NS_WARNING("Out-of-range multiplier when multiplying TimeDuration");
|
|
return TimeDuration::Forever();
|
|
}
|
|
return TimeDuration::FromTicks(mValue * int64_t(aMultiplier));
|
|
}
|
|
TimeDuration operator/(const int64_t aDivisor) const
|
|
{
|
|
return TimeDuration::FromTicks(mValue / aDivisor);
|
|
}
|
|
double operator/(const TimeDuration& aOther) const
|
|
{
|
|
return static_cast<double>(mValue) / aOther.mValue;
|
|
}
|
|
TimeDuration operator%(const TimeDuration& aOther) const
|
|
{
|
|
MOZ_ASSERT(aOther.mValue != 0, "Division by zero");
|
|
return TimeDuration::FromTicks(mValue % aOther.mValue);
|
|
}
|
|
|
|
bool operator<(const TimeDuration& aOther) const
|
|
{
|
|
return mValue < aOther.mValue;
|
|
}
|
|
bool operator<=(const TimeDuration& aOther) const
|
|
{
|
|
return mValue <= aOther.mValue;
|
|
}
|
|
bool operator>=(const TimeDuration& aOther) const
|
|
{
|
|
return mValue >= aOther.mValue;
|
|
}
|
|
bool operator>(const TimeDuration& aOther) const
|
|
{
|
|
return mValue > aOther.mValue;
|
|
}
|
|
bool operator==(const TimeDuration& aOther) const
|
|
{
|
|
return mValue == aOther.mValue;
|
|
}
|
|
bool operator!=(const TimeDuration& aOther) const
|
|
{
|
|
return mValue != aOther.mValue;
|
|
}
|
|
|
|
// Return a best guess at the system's current timing resolution,
|
|
// which might be variable. TimeDurations below this order of
|
|
// magnitude are meaningless, and those at the same order of
|
|
// magnitude or just above are suspect.
|
|
static TimeDuration Resolution() {
|
|
return FromTicks(TimeDurationPlatformUtils::ResolutionInTicks());
|
|
}
|
|
|
|
// We could define additional operators here:
|
|
// -- convert to/from other time units
|
|
// -- scale duration by a float
|
|
// but let's do that on demand.
|
|
// Comparing durations for equality will only lead to bugs on
|
|
// platforms with high-resolution timers.
|
|
|
|
private:
|
|
friend class TimeStamp;
|
|
friend struct IPC::ParamTraits<mozilla::TimeDuration>;
|
|
|
|
static TimeDuration FromTicks(int64_t aTicks)
|
|
{
|
|
TimeDuration t;
|
|
t.mValue = aTicks;
|
|
return t;
|
|
}
|
|
|
|
static TimeDuration FromTicks(double aTicks)
|
|
{
|
|
// NOTE: this MUST be a >= test, because int64_t(double(INT64_MAX))
|
|
// overflows and gives INT64_MIN.
|
|
if (aTicks >= double(INT64_MAX)) {
|
|
return TimeDuration::FromTicks(INT64_MAX);
|
|
}
|
|
|
|
// This MUST be a <= test.
|
|
if (aTicks <= double(INT64_MIN)) {
|
|
return TimeDuration::FromTicks(INT64_MIN);
|
|
}
|
|
|
|
return TimeDuration::FromTicks(int64_t(aTicks));
|
|
}
|
|
|
|
// Duration, result is implementation-specific difference of two TimeStamps
|
|
int64_t mValue;
|
|
};
|
|
|
|
/**
|
|
* Instances of this class represent moments in time, or a special
|
|
* "null" moment. We do not use the non-monotonic system clock or
|
|
* local time, since they can be reset, causing apparent backward
|
|
* travel in time, which can confuse algorithms. Instead we measure
|
|
* elapsed time according to the system. This time can never go
|
|
* backwards (i.e. it never wraps around, at least not in less than
|
|
* five million years of system elapsed time). It might not advance
|
|
* while the system is sleeping. If TimeStamp::SetNow() is not called
|
|
* at all for hours or days, we might not notice the passage of some
|
|
* of that time.
|
|
*
|
|
* We deliberately do not expose a way to convert TimeStamps to some
|
|
* particular unit. All you can do is compute a difference between two
|
|
* TimeStamps to get a TimeDuration. You can also add a TimeDuration
|
|
* to a TimeStamp to get a new TimeStamp. You can't do something
|
|
* meaningless like add two TimeStamps.
|
|
*
|
|
* Internally this is implemented as either a wrapper around
|
|
* - high-resolution, monotonic, system clocks if they exist on this
|
|
* platform
|
|
* - PRIntervalTime otherwise. We detect wraparounds of
|
|
* PRIntervalTime and work around them.
|
|
*
|
|
* This class is similar to C++11's time_point, however it is
|
|
* explicitly nullable and provides an IsNull() method. time_point
|
|
* is initialized to the clock's epoch and provides a
|
|
* time_since_epoch() method that functions similiarly. i.e.
|
|
* t.IsNull() is equivalent to t.time_since_epoch() == decltype(t)::duration::zero();
|
|
*/
|
|
class TimeStamp
|
|
{
|
|
public:
|
|
/**
|
|
* Initialize to the "null" moment
|
|
*/
|
|
MOZ_CONSTEXPR TimeStamp() : mValue(0) {}
|
|
// Default copy-constructor and assignment are OK
|
|
|
|
/**
|
|
* Return true if this is the "null" moment
|
|
*/
|
|
bool IsNull() const { return mValue == 0; }
|
|
|
|
/**
|
|
* Return a timestamp reflecting the current elapsed system time. This
|
|
* is monotonically increasing (i.e., does not decrease) over the
|
|
* lifetime of this process' XPCOM session.
|
|
*
|
|
* Now() is trying to ensure the best possible precision on each platform,
|
|
* at least one millisecond.
|
|
*
|
|
* NowLoRes() has been introduced to workaround performance problems of
|
|
* QueryPerformanceCounter on the Windows platform. NowLoRes() is giving
|
|
* lower precision, usually 15.6 ms, but with very good performance benefit.
|
|
* Use it for measurements of longer times, like >200ms timeouts.
|
|
*/
|
|
static TimeStamp Now() { return Now(true); }
|
|
static TimeStamp NowLoRes() { return Now(false); }
|
|
|
|
/**
|
|
* Return a timestamp representing the time when the current process was
|
|
* created which will be comparable with other timestamps taken with this
|
|
* class. If the actual process creation time is detected to be inconsistent
|
|
* the @a aIsInconsistent parameter will be set to true, the returned
|
|
* timestamp however will still be valid though inaccurate.
|
|
*
|
|
* @param aIsInconsistent Set to true if an inconsistency was detected in the
|
|
* process creation time
|
|
* @returns A timestamp representing the time when the process was created,
|
|
* this timestamp is always valid even when errors are reported
|
|
*/
|
|
static TimeStamp ProcessCreation(bool& aIsInconsistent);
|
|
|
|
/**
|
|
* Records a process restart. After this call ProcessCreation() will return
|
|
* the time when the browser was restarted instead of the actual time when
|
|
* the process was created.
|
|
*/
|
|
static void RecordProcessRestart();
|
|
|
|
/**
|
|
* Compute the difference between two timestamps. Both must be non-null.
|
|
*/
|
|
TimeDuration operator-(const TimeStamp& aOther) const
|
|
{
|
|
MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
|
|
MOZ_ASSERT(!aOther.IsNull(), "Cannot compute with aOther null value");
|
|
static_assert(-INT64_MAX > INT64_MIN, "int64_t sanity check");
|
|
int64_t ticks = int64_t(mValue - aOther.mValue);
|
|
// Check for overflow.
|
|
if (mValue > aOther.mValue) {
|
|
if (ticks < 0) {
|
|
ticks = INT64_MAX;
|
|
}
|
|
} else {
|
|
if (ticks > 0) {
|
|
ticks = INT64_MIN;
|
|
}
|
|
}
|
|
return TimeDuration::FromTicks(ticks);
|
|
}
|
|
|
|
TimeStamp operator+(const TimeDuration& aOther) const
|
|
{
|
|
MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
|
|
return TimeStamp(mValue + aOther.mValue);
|
|
}
|
|
TimeStamp operator-(const TimeDuration& aOther) const
|
|
{
|
|
MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
|
|
return TimeStamp(mValue - aOther.mValue);
|
|
}
|
|
TimeStamp& operator+=(const TimeDuration& aOther)
|
|
{
|
|
MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
|
|
mValue += aOther.mValue;
|
|
return *this;
|
|
}
|
|
TimeStamp& operator-=(const TimeDuration& aOther)
|
|
{
|
|
MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
|
|
mValue -= aOther.mValue;
|
|
return *this;
|
|
}
|
|
|
|
bool operator<(const TimeStamp& aOther) const
|
|
{
|
|
MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
|
|
MOZ_ASSERT(!aOther.IsNull(), "Cannot compute with aOther null value");
|
|
return mValue < aOther.mValue;
|
|
}
|
|
bool operator<=(const TimeStamp& aOther) const
|
|
{
|
|
MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
|
|
MOZ_ASSERT(!aOther.IsNull(), "Cannot compute with aOther null value");
|
|
return mValue <= aOther.mValue;
|
|
}
|
|
bool operator>=(const TimeStamp& aOther) const
|
|
{
|
|
MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
|
|
MOZ_ASSERT(!aOther.IsNull(), "Cannot compute with aOther null value");
|
|
return mValue >= aOther.mValue;
|
|
}
|
|
bool operator>(const TimeStamp& aOther) const
|
|
{
|
|
MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
|
|
MOZ_ASSERT(!aOther.IsNull(), "Cannot compute with aOther null value");
|
|
return mValue > aOther.mValue;
|
|
}
|
|
bool operator==(const TimeStamp& aOther) const
|
|
{
|
|
// Maybe it's ok to check == with null timestamps?
|
|
MOZ_ASSERT(!IsNull() && "Cannot compute with a null value");
|
|
MOZ_ASSERT(!aOther.IsNull(), "Cannot compute with aOther null value");
|
|
return mValue == aOther.mValue;
|
|
}
|
|
bool operator!=(const TimeStamp& aOther) const
|
|
{
|
|
// Maybe it's ok to check != with null timestamps?
|
|
MOZ_ASSERT(!IsNull(), "Cannot compute with a null value");
|
|
MOZ_ASSERT(!aOther.IsNull(), "Cannot compute with aOther null value");
|
|
return mValue != aOther.mValue;
|
|
}
|
|
|
|
// Comparing TimeStamps for equality should be discouraged. Adding
|
|
// two TimeStamps, or scaling TimeStamps, is nonsense and must never
|
|
// be allowed.
|
|
|
|
static nsresult Startup();
|
|
static void Shutdown();
|
|
|
|
private:
|
|
friend struct IPC::ParamTraits<mozilla::TimeStamp>;
|
|
friend void StartupTimelineRecordExternal(int, uint64_t);
|
|
|
|
MOZ_IMPLICIT TimeStamp(TimeStampValue aValue) : mValue(aValue) {}
|
|
|
|
static TimeStamp Now(bool aHighResolution);
|
|
|
|
/**
|
|
* Computes the uptime of the current process in microseconds. The result
|
|
* is platform-dependent and needs to be checked against existing timestamps
|
|
* for consistency.
|
|
*
|
|
* @returns The number of microseconds since the calling process was started
|
|
* or 0 if an error was encountered while computing the uptime
|
|
*/
|
|
static uint64_t ComputeProcessUptime();
|
|
|
|
/**
|
|
* When built with PRIntervalTime, a value of 0 means this instance
|
|
* is "null". Otherwise, the low 32 bits represent a PRIntervalTime,
|
|
* and the high 32 bits represent a counter of the number of
|
|
* rollovers of PRIntervalTime that we've seen. This counter starts
|
|
* at 1 to avoid a real time colliding with the "null" value.
|
|
*
|
|
* PR_INTERVAL_MAX is set at 100,000 ticks per second. So the minimum
|
|
* time to wrap around is about 2^64/100000 seconds, i.e. about
|
|
* 5,849,424 years.
|
|
*
|
|
* When using a system clock, a value is system dependent.
|
|
*/
|
|
TimeStampValue mValue;
|
|
};
|
|
|
|
}
|
|
|
|
#endif /* mozilla_TimeStamp_h */
|