2014-08-06 09:35:21 +00:00
|
|
|
// Copyright 2014 the V8 project authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
|
|
// found in the LICENSE file.
|
|
|
|
|
|
|
|
#include "src/base/platform/time.h"
|
|
|
|
|
2014-08-06 09:50:17 +00:00
|
|
|
#if V8_OS_MACOSX
|
|
|
|
#include <mach/mach_time.h>
|
|
|
|
#endif
|
2014-08-06 09:35:21 +00:00
|
|
|
#if V8_OS_POSIX
|
|
|
|
#include <sys/time.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if V8_OS_WIN
|
|
|
|
#include "src/base/win32-headers.h"
|
|
|
|
#endif
|
|
|
|
|
2016-06-01 18:52:39 +00:00
|
|
|
#include <vector>
|
|
|
|
|
2014-08-06 09:35:21 +00:00
|
|
|
#include "src/base/platform/elapsed-timer.h"
|
2016-05-13 11:05:24 +00:00
|
|
|
#include "src/base/platform/platform.h"
|
2014-08-06 09:35:21 +00:00
|
|
|
#include "testing/gtest/include/gtest/gtest.h"
|
|
|
|
|
|
|
|
namespace v8 {
|
|
|
|
namespace base {
|
|
|
|
|
2018-02-02 14:52:03 +00:00
|
|
|
TEST(TimeDelta, ZeroMinMax) {
|
|
|
|
constexpr TimeDelta kZero;
|
|
|
|
static_assert(kZero.IsZero(), "");
|
|
|
|
|
|
|
|
constexpr TimeDelta kMax = TimeDelta::Max();
|
|
|
|
static_assert(kMax.IsMax(), "");
|
|
|
|
static_assert(kMax == TimeDelta::Max(), "");
|
|
|
|
EXPECT_GT(kMax, TimeDelta::FromDays(100 * 365));
|
|
|
|
static_assert(kMax > kZero, "");
|
|
|
|
|
|
|
|
constexpr TimeDelta kMin = TimeDelta::Min();
|
|
|
|
static_assert(kMin.IsMin(), "");
|
|
|
|
static_assert(kMin == TimeDelta::Min(), "");
|
|
|
|
EXPECT_LT(kMin, TimeDelta::FromDays(-100 * 365));
|
|
|
|
static_assert(kMin < kZero, "");
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(TimeDelta, MaxConversions) {
|
|
|
|
// static_assert also confirms constexpr works as intended.
|
|
|
|
constexpr TimeDelta kMax = TimeDelta::Max();
|
|
|
|
EXPECT_EQ(kMax.InDays(), std::numeric_limits<int>::max());
|
|
|
|
EXPECT_EQ(kMax.InHours(), std::numeric_limits<int>::max());
|
|
|
|
EXPECT_EQ(kMax.InMinutes(), std::numeric_limits<int>::max());
|
|
|
|
EXPECT_EQ(kMax.InSecondsF(), std::numeric_limits<double>::infinity());
|
|
|
|
EXPECT_EQ(kMax.InSeconds(), std::numeric_limits<int64_t>::max());
|
|
|
|
EXPECT_EQ(kMax.InMillisecondsF(), std::numeric_limits<double>::infinity());
|
|
|
|
EXPECT_EQ(kMax.InMilliseconds(), std::numeric_limits<int64_t>::max());
|
|
|
|
EXPECT_EQ(kMax.InMillisecondsRoundedUp(),
|
|
|
|
std::numeric_limits<int64_t>::max());
|
|
|
|
|
|
|
|
// TODO(v8-team): Import overflow support from Chromium's base.
|
|
|
|
|
|
|
|
// EXPECT_TRUE(TimeDelta::FromDays(std::numeric_limits<int>::max()).IsMax());
|
|
|
|
|
|
|
|
// EXPECT_TRUE(
|
|
|
|
// TimeDelta::FromHours(std::numeric_limits<int>::max()).IsMax());
|
|
|
|
|
|
|
|
// EXPECT_TRUE(
|
|
|
|
// TimeDelta::FromMinutes(std::numeric_limits<int>::max()).IsMax());
|
|
|
|
|
|
|
|
// constexpr int64_t max_int = std::numeric_limits<int64_t>::max();
|
|
|
|
// constexpr int64_t min_int = std::numeric_limits<int64_t>::min();
|
|
|
|
|
|
|
|
// EXPECT_TRUE(
|
|
|
|
// TimeDelta::FromSeconds(max_int / Time::kMicrosecondsPerSecond + 1)
|
|
|
|
// .IsMax());
|
|
|
|
|
|
|
|
// EXPECT_TRUE(TimeDelta::FromMilliseconds(
|
|
|
|
// max_int / Time::kMillisecondsPerSecond + 1)
|
|
|
|
// .IsMax());
|
|
|
|
|
|
|
|
// EXPECT_TRUE(TimeDelta::FromMicroseconds(max_int).IsMax());
|
|
|
|
|
|
|
|
// EXPECT_TRUE(
|
|
|
|
// TimeDelta::FromSeconds(min_int / Time::kMicrosecondsPerSecond - 1)
|
|
|
|
// .IsMin());
|
|
|
|
|
|
|
|
// EXPECT_TRUE(TimeDelta::FromMilliseconds(
|
|
|
|
// min_int / Time::kMillisecondsPerSecond - 1)
|
|
|
|
// .IsMin());
|
|
|
|
|
|
|
|
// EXPECT_TRUE(TimeDelta::FromMicroseconds(min_int).IsMin());
|
|
|
|
|
|
|
|
// EXPECT_TRUE(
|
|
|
|
// TimeDelta::FromMicroseconds(std::numeric_limits<int64_t>::min())
|
|
|
|
// .IsMin());
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(TimeDelta, NumericOperators) {
|
|
|
|
constexpr int i = 2;
|
|
|
|
EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
|
|
|
|
(TimeDelta::FromMilliseconds(1000) * i));
|
|
|
|
EXPECT_EQ(TimeDelta::FromMilliseconds(500),
|
|
|
|
(TimeDelta::FromMilliseconds(1000) / i));
|
|
|
|
EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
|
|
|
|
(TimeDelta::FromMilliseconds(1000) *= i));
|
|
|
|
EXPECT_EQ(TimeDelta::FromMilliseconds(500),
|
|
|
|
(TimeDelta::FromMilliseconds(1000) /= i));
|
|
|
|
|
|
|
|
constexpr int64_t i64 = 2;
|
|
|
|
EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
|
|
|
|
(TimeDelta::FromMilliseconds(1000) * i64));
|
|
|
|
EXPECT_EQ(TimeDelta::FromMilliseconds(500),
|
|
|
|
(TimeDelta::FromMilliseconds(1000) / i64));
|
|
|
|
EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
|
|
|
|
(TimeDelta::FromMilliseconds(1000) *= i64));
|
|
|
|
EXPECT_EQ(TimeDelta::FromMilliseconds(500),
|
|
|
|
(TimeDelta::FromMilliseconds(1000) /= i64));
|
|
|
|
|
|
|
|
EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
|
|
|
|
(TimeDelta::FromMilliseconds(1000) * 2));
|
|
|
|
EXPECT_EQ(TimeDelta::FromMilliseconds(500),
|
|
|
|
(TimeDelta::FromMilliseconds(1000) / 2));
|
|
|
|
EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
|
|
|
|
(TimeDelta::FromMilliseconds(1000) *= 2));
|
|
|
|
EXPECT_EQ(TimeDelta::FromMilliseconds(500),
|
|
|
|
(TimeDelta::FromMilliseconds(1000) /= 2));
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO(v8-team): Import support for overflow from Chromium's base.
|
|
|
|
TEST(TimeDelta, DISABLED_Overflows) {
|
|
|
|
// Some sanity checks. static_assert's used were possible to verify constexpr
|
|
|
|
// evaluation at the same time.
|
|
|
|
static_assert(TimeDelta::Max().IsMax(), "");
|
|
|
|
static_assert(-TimeDelta::Max() < TimeDelta(), "");
|
|
|
|
static_assert(-TimeDelta::Max() > TimeDelta::Min(), "");
|
|
|
|
static_assert(TimeDelta() > -TimeDelta::Max(), "");
|
|
|
|
|
|
|
|
TimeDelta large_delta = TimeDelta::Max() - TimeDelta::FromMilliseconds(1);
|
|
|
|
TimeDelta large_negative = -large_delta;
|
|
|
|
EXPECT_GT(TimeDelta(), large_negative);
|
|
|
|
EXPECT_FALSE(large_delta.IsMax());
|
|
|
|
EXPECT_FALSE((-large_negative).IsMin());
|
|
|
|
const TimeDelta kOneSecond = TimeDelta::FromSeconds(1);
|
|
|
|
|
|
|
|
// Test +, -, * and / operators.
|
|
|
|
EXPECT_TRUE((large_delta + kOneSecond).IsMax());
|
|
|
|
EXPECT_TRUE((large_negative + (-kOneSecond)).IsMin());
|
|
|
|
EXPECT_TRUE((large_negative - kOneSecond).IsMin());
|
|
|
|
EXPECT_TRUE((large_delta - (-kOneSecond)).IsMax());
|
|
|
|
EXPECT_TRUE((large_delta * 2).IsMax());
|
|
|
|
EXPECT_TRUE((large_delta * -2).IsMin());
|
|
|
|
|
|
|
|
// Test +=, -=, *= and /= operators.
|
|
|
|
TimeDelta delta = large_delta;
|
|
|
|
delta += kOneSecond;
|
|
|
|
EXPECT_TRUE(delta.IsMax());
|
|
|
|
delta = large_negative;
|
|
|
|
delta += -kOneSecond;
|
|
|
|
EXPECT_TRUE((delta).IsMin());
|
|
|
|
|
|
|
|
delta = large_negative;
|
|
|
|
delta -= kOneSecond;
|
|
|
|
EXPECT_TRUE((delta).IsMin());
|
|
|
|
delta = large_delta;
|
|
|
|
delta -= -kOneSecond;
|
|
|
|
EXPECT_TRUE(delta.IsMax());
|
|
|
|
|
|
|
|
delta = large_delta;
|
|
|
|
delta *= 2;
|
|
|
|
EXPECT_TRUE(delta.IsMax());
|
|
|
|
|
|
|
|
// Test operations with Time and TimeTicks.
|
|
|
|
EXPECT_TRUE((large_delta + Time::Now()).IsMax());
|
|
|
|
EXPECT_TRUE((large_delta + TimeTicks::Now()).IsMax());
|
|
|
|
EXPECT_TRUE((Time::Now() + large_delta).IsMax());
|
|
|
|
EXPECT_TRUE((TimeTicks::Now() + large_delta).IsMax());
|
|
|
|
|
|
|
|
Time time_now = Time::Now();
|
|
|
|
EXPECT_EQ(kOneSecond, (time_now + kOneSecond) - time_now);
|
|
|
|
EXPECT_EQ(-kOneSecond, (time_now - kOneSecond) - time_now);
|
|
|
|
|
|
|
|
TimeTicks ticks_now = TimeTicks::Now();
|
|
|
|
EXPECT_EQ(-kOneSecond, (ticks_now - kOneSecond) - ticks_now);
|
|
|
|
EXPECT_EQ(kOneSecond, (ticks_now + kOneSecond) - ticks_now);
|
|
|
|
}
|
|
|
|
|
2014-08-06 09:35:21 +00:00
|
|
|
TEST(TimeDelta, FromAndIn) {
|
|
|
|
EXPECT_EQ(TimeDelta::FromDays(2), TimeDelta::FromHours(48));
|
|
|
|
EXPECT_EQ(TimeDelta::FromHours(3), TimeDelta::FromMinutes(180));
|
|
|
|
EXPECT_EQ(TimeDelta::FromMinutes(2), TimeDelta::FromSeconds(120));
|
|
|
|
EXPECT_EQ(TimeDelta::FromSeconds(2), TimeDelta::FromMilliseconds(2000));
|
|
|
|
EXPECT_EQ(TimeDelta::FromMilliseconds(2), TimeDelta::FromMicroseconds(2000));
|
|
|
|
EXPECT_EQ(static_cast<int>(13), TimeDelta::FromDays(13).InDays());
|
|
|
|
EXPECT_EQ(static_cast<int>(13), TimeDelta::FromHours(13).InHours());
|
|
|
|
EXPECT_EQ(static_cast<int>(13), TimeDelta::FromMinutes(13).InMinutes());
|
|
|
|
EXPECT_EQ(static_cast<int64_t>(13), TimeDelta::FromSeconds(13).InSeconds());
|
2014-08-06 10:23:04 +00:00
|
|
|
EXPECT_DOUBLE_EQ(13.0, TimeDelta::FromSeconds(13).InSecondsF());
|
2014-08-06 09:35:21 +00:00
|
|
|
EXPECT_EQ(static_cast<int64_t>(13),
|
|
|
|
TimeDelta::FromMilliseconds(13).InMilliseconds());
|
2014-08-06 10:23:04 +00:00
|
|
|
EXPECT_DOUBLE_EQ(13.0, TimeDelta::FromMilliseconds(13).InMillisecondsF());
|
2014-08-06 09:35:21 +00:00
|
|
|
EXPECT_EQ(static_cast<int64_t>(13),
|
|
|
|
TimeDelta::FromMicroseconds(13).InMicroseconds());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#if V8_OS_MACOSX
|
|
|
|
TEST(TimeDelta, MachTimespec) {
|
|
|
|
TimeDelta null = TimeDelta();
|
|
|
|
EXPECT_EQ(null, TimeDelta::FromMachTimespec(null.ToMachTimespec()));
|
|
|
|
TimeDelta delta1 = TimeDelta::FromMilliseconds(42);
|
|
|
|
EXPECT_EQ(delta1, TimeDelta::FromMachTimespec(delta1.ToMachTimespec()));
|
|
|
|
TimeDelta delta2 = TimeDelta::FromDays(42);
|
|
|
|
EXPECT_EQ(delta2, TimeDelta::FromMachTimespec(delta2.ToMachTimespec()));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2018-02-02 14:52:03 +00:00
|
|
|
TEST(Time, Max) {
|
|
|
|
Time max = Time::Max();
|
|
|
|
EXPECT_TRUE(max.IsMax());
|
|
|
|
EXPECT_EQ(max, Time::Max());
|
|
|
|
EXPECT_GT(max, Time::Now());
|
|
|
|
EXPECT_GT(max, Time());
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(Time, MaxConversions) {
|
|
|
|
Time t = Time::Max();
|
|
|
|
EXPECT_EQ(std::numeric_limits<int64_t>::max(), t.ToInternalValue());
|
|
|
|
|
|
|
|
// TODO(v8-team): Time::FromJsTime() overflows with infinity. Import support
|
|
|
|
// from Chromium's base.
|
|
|
|
// t = Time::FromJsTime(std::numeric_limits<double>::infinity());
|
|
|
|
// EXPECT_TRUE(t.IsMax());
|
|
|
|
// EXPECT_EQ(std::numeric_limits<double>::infinity(), t.ToJsTime());
|
|
|
|
|
|
|
|
#if defined(OS_POSIX)
|
|
|
|
struct timeval tval;
|
|
|
|
tval.tv_sec = std::numeric_limits<time_t>::max();
|
|
|
|
tval.tv_usec = static_cast<suseconds_t>(Time::kMicrosecondsPerSecond) - 1;
|
|
|
|
t = Time::FromTimeVal(tval);
|
|
|
|
EXPECT_TRUE(t.IsMax());
|
|
|
|
tval = t.ToTimeVal();
|
|
|
|
EXPECT_EQ(std::numeric_limits<time_t>::max(), tval.tv_sec);
|
|
|
|
EXPECT_EQ(static_cast<suseconds_t>(Time::kMicrosecondsPerSecond) - 1,
|
|
|
|
tval.tv_usec);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(OS_WIN)
|
|
|
|
FILETIME ftime;
|
|
|
|
ftime.dwHighDateTime = std::numeric_limits<DWORD>::max();
|
|
|
|
ftime.dwLowDateTime = std::numeric_limits<DWORD>::max();
|
|
|
|
t = Time::FromFileTime(ftime);
|
|
|
|
EXPECT_TRUE(t.IsMax());
|
|
|
|
ftime = t.ToFileTime();
|
|
|
|
EXPECT_EQ(std::numeric_limits<DWORD>::max(), ftime.dwHighDateTime);
|
|
|
|
EXPECT_EQ(std::numeric_limits<DWORD>::max(), ftime.dwLowDateTime);
|
|
|
|
#endif
|
|
|
|
}
|
2014-08-06 09:35:21 +00:00
|
|
|
|
|
|
|
TEST(Time, JsTime) {
|
|
|
|
Time t = Time::FromJsTime(700000.3);
|
2014-08-06 10:23:04 +00:00
|
|
|
EXPECT_DOUBLE_EQ(700000.3, t.ToJsTime());
|
2014-08-06 09:35:21 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#if V8_OS_POSIX
|
|
|
|
TEST(Time, Timespec) {
|
|
|
|
Time null;
|
|
|
|
EXPECT_TRUE(null.IsNull());
|
|
|
|
EXPECT_EQ(null, Time::FromTimespec(null.ToTimespec()));
|
|
|
|
Time now = Time::Now();
|
|
|
|
EXPECT_EQ(now, Time::FromTimespec(now.ToTimespec()));
|
|
|
|
Time now_sys = Time::NowFromSystemTime();
|
|
|
|
EXPECT_EQ(now_sys, Time::FromTimespec(now_sys.ToTimespec()));
|
|
|
|
Time unix_epoch = Time::UnixEpoch();
|
|
|
|
EXPECT_EQ(unix_epoch, Time::FromTimespec(unix_epoch.ToTimespec()));
|
|
|
|
Time max = Time::Max();
|
|
|
|
EXPECT_TRUE(max.IsMax());
|
|
|
|
EXPECT_EQ(max, Time::FromTimespec(max.ToTimespec()));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
TEST(Time, Timeval) {
|
|
|
|
Time null;
|
|
|
|
EXPECT_TRUE(null.IsNull());
|
|
|
|
EXPECT_EQ(null, Time::FromTimeval(null.ToTimeval()));
|
|
|
|
Time now = Time::Now();
|
|
|
|
EXPECT_EQ(now, Time::FromTimeval(now.ToTimeval()));
|
|
|
|
Time now_sys = Time::NowFromSystemTime();
|
|
|
|
EXPECT_EQ(now_sys, Time::FromTimeval(now_sys.ToTimeval()));
|
|
|
|
Time unix_epoch = Time::UnixEpoch();
|
|
|
|
EXPECT_EQ(unix_epoch, Time::FromTimeval(unix_epoch.ToTimeval()));
|
|
|
|
Time max = Time::Max();
|
|
|
|
EXPECT_TRUE(max.IsMax());
|
|
|
|
EXPECT_EQ(max, Time::FromTimeval(max.ToTimeval()));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if V8_OS_WIN
|
|
|
|
TEST(Time, Filetime) {
|
|
|
|
Time null;
|
|
|
|
EXPECT_TRUE(null.IsNull());
|
|
|
|
EXPECT_EQ(null, Time::FromFiletime(null.ToFiletime()));
|
|
|
|
Time now = Time::Now();
|
|
|
|
EXPECT_EQ(now, Time::FromFiletime(now.ToFiletime()));
|
|
|
|
Time now_sys = Time::NowFromSystemTime();
|
|
|
|
EXPECT_EQ(now_sys, Time::FromFiletime(now_sys.ToFiletime()));
|
|
|
|
Time unix_epoch = Time::UnixEpoch();
|
|
|
|
EXPECT_EQ(unix_epoch, Time::FromFiletime(unix_epoch.ToFiletime()));
|
|
|
|
Time max = Time::Max();
|
|
|
|
EXPECT_TRUE(max.IsMax());
|
|
|
|
EXPECT_EQ(max, Time::FromFiletime(max.ToFiletime()));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
|
|
template <typename T>
|
|
|
|
static void ResolutionTest(T (*Now)(), TimeDelta target_granularity) {
|
|
|
|
// We're trying to measure that intervals increment in a VERY small amount
|
|
|
|
// of time -- according to the specified target granularity. Unfortunately,
|
|
|
|
// if we happen to have a context switch in the middle of our test, the
|
|
|
|
// context switch could easily exceed our limit. So, we iterate on this
|
|
|
|
// several times. As long as we're able to detect the fine-granularity
|
|
|
|
// timers at least once, then the test has succeeded.
|
|
|
|
static const TimeDelta kExpirationTimeout = TimeDelta::FromSeconds(1);
|
|
|
|
ElapsedTimer timer;
|
|
|
|
timer.Start();
|
|
|
|
TimeDelta delta;
|
|
|
|
do {
|
|
|
|
T start = Now();
|
|
|
|
T now = start;
|
|
|
|
// Loop until we can detect that the clock has changed. Non-HighRes timers
|
|
|
|
// will increment in chunks, i.e. 15ms. By spinning until we see a clock
|
|
|
|
// change, we detect the minimum time between measurements.
|
|
|
|
do {
|
|
|
|
now = Now();
|
|
|
|
delta = now - start;
|
|
|
|
} while (now <= start);
|
|
|
|
EXPECT_NE(static_cast<int64_t>(0), delta.InMicroseconds());
|
|
|
|
} while (delta > target_granularity && !timer.HasExpired(kExpirationTimeout));
|
|
|
|
EXPECT_LE(delta, target_granularity);
|
|
|
|
}
|
|
|
|
|
2014-08-29 10:53:08 +00:00
|
|
|
} // namespace
|
2014-08-06 09:35:21 +00:00
|
|
|
|
|
|
|
|
|
|
|
TEST(Time, NowResolution) {
|
|
|
|
// We assume that Time::Now() has at least 16ms resolution.
|
|
|
|
static const TimeDelta kTargetGranularity = TimeDelta::FromMilliseconds(16);
|
|
|
|
ResolutionTest<Time>(&Time::Now, kTargetGranularity);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
TEST(TimeTicks, NowResolution) {
|
2018-02-01 09:44:35 +00:00
|
|
|
// TimeTicks::Now() is documented as having "no worse than one microsecond"
|
|
|
|
// resolution. Unless !TimeTicks::IsHighResolution() in which case the clock
|
|
|
|
// could be as coarse as ~15.6ms.
|
|
|
|
const TimeDelta kTargetGranularity = TimeTicks::IsHighResolution()
|
|
|
|
? TimeDelta::FromMicroseconds(1)
|
|
|
|
: TimeDelta::FromMilliseconds(16);
|
2014-08-06 09:35:21 +00:00
|
|
|
ResolutionTest<TimeTicks>(&TimeTicks::Now, kTargetGranularity);
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(TimeTicks, IsMonotonic) {
|
|
|
|
TimeTicks previous_normal_ticks;
|
|
|
|
TimeTicks previous_highres_ticks;
|
|
|
|
ElapsedTimer timer;
|
|
|
|
timer.Start();
|
|
|
|
while (!timer.HasExpired(TimeDelta::FromMilliseconds(100))) {
|
|
|
|
TimeTicks normal_ticks = TimeTicks::Now();
|
|
|
|
TimeTicks highres_ticks = TimeTicks::HighResolutionNow();
|
|
|
|
EXPECT_GE(normal_ticks, previous_normal_ticks);
|
|
|
|
EXPECT_GE((normal_ticks - previous_normal_ticks).InMicroseconds(), 0);
|
|
|
|
EXPECT_GE(highres_ticks, previous_highres_ticks);
|
|
|
|
EXPECT_GE((highres_ticks - previous_highres_ticks).InMicroseconds(), 0);
|
|
|
|
previous_normal_ticks = normal_ticks;
|
|
|
|
previous_highres_ticks = highres_ticks;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-13 11:05:24 +00:00
|
|
|
|
2016-06-01 18:52:39 +00:00
|
|
|
#if V8_OS_ANDROID
|
2016-05-13 11:05:24 +00:00
|
|
|
#define MAYBE_ThreadNow DISABLED_ThreadNow
|
|
|
|
#else
|
|
|
|
#define MAYBE_ThreadNow ThreadNow
|
|
|
|
#endif
|
|
|
|
TEST(ThreadTicks, MAYBE_ThreadNow) {
|
|
|
|
if (ThreadTicks::IsSupported()) {
|
2016-06-30 15:34:34 +00:00
|
|
|
ThreadTicks::WaitUntilInitialized();
|
2016-05-13 11:05:24 +00:00
|
|
|
TimeTicks begin = TimeTicks::Now();
|
|
|
|
ThreadTicks begin_thread = ThreadTicks::Now();
|
|
|
|
// Make sure that ThreadNow value is non-zero.
|
|
|
|
EXPECT_GT(begin_thread, ThreadTicks());
|
|
|
|
// Sleep for 10 milliseconds to get the thread de-scheduled.
|
|
|
|
OS::Sleep(base::TimeDelta::FromMilliseconds(10));
|
|
|
|
ThreadTicks end_thread = ThreadTicks::Now();
|
|
|
|
TimeTicks end = TimeTicks::Now();
|
|
|
|
TimeDelta delta = end - begin;
|
|
|
|
TimeDelta delta_thread = end_thread - begin_thread;
|
|
|
|
// Make sure that some thread time have elapsed.
|
|
|
|
EXPECT_GT(delta_thread.InMicroseconds(), 0);
|
|
|
|
// But the thread time is at least 9ms less than clock time.
|
|
|
|
TimeDelta difference = delta - delta_thread;
|
|
|
|
EXPECT_GE(difference.InMicroseconds(), 9000);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-01 18:52:39 +00:00
|
|
|
|
|
|
|
#if V8_OS_WIN
|
|
|
|
TEST(TimeTicks, TimerPerformance) {
|
|
|
|
// Verify that various timer mechanisms can always complete quickly.
|
|
|
|
// Note: This is a somewhat arbitrary test.
|
|
|
|
const int kLoops = 10000;
|
|
|
|
|
|
|
|
typedef TimeTicks (*TestFunc)();
|
|
|
|
struct TestCase {
|
|
|
|
TestFunc func;
|
|
|
|
const char *description;
|
|
|
|
};
|
|
|
|
// Cheating a bit here: assumes sizeof(TimeTicks) == sizeof(Time)
|
|
|
|
// in order to create a single test case list.
|
|
|
|
static_assert(sizeof(TimeTicks) == sizeof(Time),
|
|
|
|
"TimeTicks and Time must be the same size");
|
|
|
|
std::vector<TestCase> cases;
|
|
|
|
cases.push_back({reinterpret_cast<TestFunc>(&Time::Now), "Time::Now"});
|
|
|
|
cases.push_back({&TimeTicks::Now, "TimeTicks::Now"});
|
|
|
|
|
|
|
|
if (ThreadTicks::IsSupported()) {
|
|
|
|
ThreadTicks::WaitUntilInitialized();
|
|
|
|
cases.push_back(
|
|
|
|
{reinterpret_cast<TestFunc>(&ThreadTicks::Now), "ThreadTicks::Now"});
|
|
|
|
}
|
|
|
|
|
|
|
|
for (const auto& test_case : cases) {
|
|
|
|
TimeTicks start = TimeTicks::Now();
|
|
|
|
for (int index = 0; index < kLoops; index++)
|
|
|
|
test_case.func();
|
|
|
|
TimeTicks stop = TimeTicks::Now();
|
2017-08-02 08:23:36 +00:00
|
|
|
// Turning off the check for acceptable delays. Without this check,
|
2016-06-01 18:52:39 +00:00
|
|
|
// the test really doesn't do much other than measure. But the
|
|
|
|
// measurements are still useful for testing timers on various platforms.
|
|
|
|
// The reason to remove the check is because the tests run on many
|
|
|
|
// buildbots, some of which are VMs. These machines can run horribly
|
|
|
|
// slow, and there is really no value for checking against a max timer.
|
2017-08-02 08:23:36 +00:00
|
|
|
// const int kMaxTime = 35; // Maximum acceptable milliseconds for test.
|
2016-06-01 18:52:39 +00:00
|
|
|
// EXPECT_LT((stop - start).InMilliseconds(), kMaxTime);
|
|
|
|
printf("%s: %1.2fus per call\n", test_case.description,
|
|
|
|
(stop - start).InMillisecondsF() * 1000 / kLoops);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif // V8_OS_WIN
|
|
|
|
|
2014-08-06 09:35:21 +00:00
|
|
|
} // namespace base
|
|
|
|
} // namespace v8
|