v8/test/unittests/base/platform/time-unittest.cc

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

454 lines
16 KiB
C++
Raw Normal View History

// 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"
#if V8_OS_MACOSX
#include <mach/mach_time.h>
#endif
#if V8_OS_POSIX
#include <sys/time.h>
#endif
#if V8_OS_WIN
#include "src/base/win32-headers.h"
#endif
#include <vector>
#include "src/base/platform/elapsed-timer.h"
Reland of [Reland] Implement CPU time for OS X and POSIX. (patchset #1 id:1 of https://codereview.chromium.org/1977753002/ ) Reason for revert: Not the culprit sorry. Original issue's description: > Revert of [Reland] Implement CPU time for OS X and POSIX. (patchset #1 id:1 of https://codereview.chromium.org/1966183003/ ) > > Reason for revert: > Blocks roll: https://codereview.chromium.org/1972303002/ > > Original issue's description: > > [Reland] Implement CPU time for OS X and POSIX. > > > > V8 tracing controller uses 2 clocks: wall clock and cpu clock. This patch > > implements CPU time for OS X and POSIX to provide more accurate > > accounting of CPU time used by each thread. > > > > BUG=v8:4984 > > LOG=n > > > > Committed: https://crrev.com/efa27fb25e1fa5b8465f4af710086b73b0cba660 > > Cr-Commit-Position: refs/heads/master@{#36213} > > TBR=fmeawad@chromium.org,jochen@chromium.org,rsesek@chromium.org,bmeurer@chromium.org,lpy@chromium.org > # Skipping CQ checks because original CL landed less than 1 days ago. > NOPRESUBMIT=true > NOTREECHECKS=true > NOTRY=true > BUG=v8:4984 > > Committed: https://crrev.com/31b9ba3bc8fb93601cc73c83213b30e639d448b3 > Cr-Commit-Position: refs/heads/master@{#36225} TBR=fmeawad@chromium.org,jochen@chromium.org,rsesek@chromium.org,bmeurer@chromium.org,lpy@chromium.org # Skipping CQ checks because original CL landed less than 1 days ago. NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true BUG=v8:4984 Review-Url: https://codereview.chromium.org/1976603005 Cr-Commit-Position: refs/heads/master@{#36233}
2016-05-13 11:05:24 +00:00
#include "src/base/platform/platform.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace v8 {
namespace base {
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);
}
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());
EXPECT_DOUBLE_EQ(13.0, TimeDelta::FromSeconds(13).InSecondsF());
EXPECT_EQ(static_cast<int64_t>(13),
TimeDelta::FromMilliseconds(13).InMilliseconds());
EXPECT_DOUBLE_EQ(13.0, TimeDelta::FromMilliseconds(13).InMillisecondsF());
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
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
}
TEST(Time, JsTime) {
Time t = Time::FromJsTime(700000.3);
EXPECT_DOUBLE_EQ(700000.3, t.ToJsTime());
}
#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);
}
} // namespace
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) {
Make TimeTicks::Now() high-resolution whenever possible with low-latency. It was already always high-resolution on POSIX but was never high resolution on Windows. Windows does support low latency high-resolution timers for the majority of our user base. TimeTicks::HighResolutionNow() was only explicitly requested in testing frameworks. As such I left the call in place but made it DCHECK that it's running on a Windows machine on which high-resolution clocks are used. This confirms that none of our test fleet has regressed with this change (the previous HighResolutionNow() used to be slightly more aggressive and also do it in a few configurations where we now fallback to low-resolution now). This implementation was copied as-is (modulo minor v8 API compatibility tweaks). These implementations were the same in the past but had diverged when, sadly, the same bug was fixed separately years apart, in Chromium and V8: chromium: https://codereview.chromium.org/1284053004 + https://codereview.chromium.org/2393953003 v8: https://codereview.chromium.org/1304873011 This is a prerequisite to add metrics around parallel task execution (low-resolution clocks are useless at that level, but we also don't want to incur high-latency clocks on machines that can't afford it cheaply). Bug: chromium:807606 Change-Id: Id18e7be895d8431ebd0e565a1bdf358fe7838489 Reviewed-on: https://chromium-review.googlesource.com/897485 Reviewed-by: Hannes Payer <hpayer@chromium.org> Commit-Queue: Gabriel Charette <gab@chromium.org> Cr-Commit-Position: refs/heads/master@{#51027}
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);
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;
}
}
Reland of [Reland] Implement CPU time for OS X and POSIX. (patchset #1 id:1 of https://codereview.chromium.org/1977753002/ ) Reason for revert: Not the culprit sorry. Original issue's description: > Revert of [Reland] Implement CPU time for OS X and POSIX. (patchset #1 id:1 of https://codereview.chromium.org/1966183003/ ) > > Reason for revert: > Blocks roll: https://codereview.chromium.org/1972303002/ > > Original issue's description: > > [Reland] Implement CPU time for OS X and POSIX. > > > > V8 tracing controller uses 2 clocks: wall clock and cpu clock. This patch > > implements CPU time for OS X and POSIX to provide more accurate > > accounting of CPU time used by each thread. > > > > BUG=v8:4984 > > LOG=n > > > > Committed: https://crrev.com/efa27fb25e1fa5b8465f4af710086b73b0cba660 > > Cr-Commit-Position: refs/heads/master@{#36213} > > TBR=fmeawad@chromium.org,jochen@chromium.org,rsesek@chromium.org,bmeurer@chromium.org,lpy@chromium.org > # Skipping CQ checks because original CL landed less than 1 days ago. > NOPRESUBMIT=true > NOTREECHECKS=true > NOTRY=true > BUG=v8:4984 > > Committed: https://crrev.com/31b9ba3bc8fb93601cc73c83213b30e639d448b3 > Cr-Commit-Position: refs/heads/master@{#36225} TBR=fmeawad@chromium.org,jochen@chromium.org,rsesek@chromium.org,bmeurer@chromium.org,lpy@chromium.org # Skipping CQ checks because original CL landed less than 1 days ago. NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true BUG=v8:4984 Review-Url: https://codereview.chromium.org/1976603005 Cr-Commit-Position: refs/heads/master@{#36233}
2016-05-13 11:05:24 +00:00
#if V8_OS_ANDROID
Reland of [Reland] Implement CPU time for OS X and POSIX. (patchset #1 id:1 of https://codereview.chromium.org/1977753002/ ) Reason for revert: Not the culprit sorry. Original issue's description: > Revert of [Reland] Implement CPU time for OS X and POSIX. (patchset #1 id:1 of https://codereview.chromium.org/1966183003/ ) > > Reason for revert: > Blocks roll: https://codereview.chromium.org/1972303002/ > > Original issue's description: > > [Reland] Implement CPU time for OS X and POSIX. > > > > V8 tracing controller uses 2 clocks: wall clock and cpu clock. This patch > > implements CPU time for OS X and POSIX to provide more accurate > > accounting of CPU time used by each thread. > > > > BUG=v8:4984 > > LOG=n > > > > Committed: https://crrev.com/efa27fb25e1fa5b8465f4af710086b73b0cba660 > > Cr-Commit-Position: refs/heads/master@{#36213} > > TBR=fmeawad@chromium.org,jochen@chromium.org,rsesek@chromium.org,bmeurer@chromium.org,lpy@chromium.org > # Skipping CQ checks because original CL landed less than 1 days ago. > NOPRESUBMIT=true > NOTREECHECKS=true > NOTRY=true > BUG=v8:4984 > > Committed: https://crrev.com/31b9ba3bc8fb93601cc73c83213b30e639d448b3 > Cr-Commit-Position: refs/heads/master@{#36225} TBR=fmeawad@chromium.org,jochen@chromium.org,rsesek@chromium.org,bmeurer@chromium.org,lpy@chromium.org # Skipping CQ checks because original CL landed less than 1 days ago. NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true BUG=v8:4984 Review-Url: https://codereview.chromium.org/1976603005 Cr-Commit-Position: refs/heads/master@{#36233}
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()) {
ThreadTicks::WaitUntilInitialized();
Reland of [Reland] Implement CPU time for OS X and POSIX. (patchset #1 id:1 of https://codereview.chromium.org/1977753002/ ) Reason for revert: Not the culprit sorry. Original issue's description: > Revert of [Reland] Implement CPU time for OS X and POSIX. (patchset #1 id:1 of https://codereview.chromium.org/1966183003/ ) > > Reason for revert: > Blocks roll: https://codereview.chromium.org/1972303002/ > > Original issue's description: > > [Reland] Implement CPU time for OS X and POSIX. > > > > V8 tracing controller uses 2 clocks: wall clock and cpu clock. This patch > > implements CPU time for OS X and POSIX to provide more accurate > > accounting of CPU time used by each thread. > > > > BUG=v8:4984 > > LOG=n > > > > Committed: https://crrev.com/efa27fb25e1fa5b8465f4af710086b73b0cba660 > > Cr-Commit-Position: refs/heads/master@{#36213} > > TBR=fmeawad@chromium.org,jochen@chromium.org,rsesek@chromium.org,bmeurer@chromium.org,lpy@chromium.org > # Skipping CQ checks because original CL landed less than 1 days ago. > NOPRESUBMIT=true > NOTREECHECKS=true > NOTRY=true > BUG=v8:4984 > > Committed: https://crrev.com/31b9ba3bc8fb93601cc73c83213b30e639d448b3 > Cr-Commit-Position: refs/heads/master@{#36225} TBR=fmeawad@chromium.org,jochen@chromium.org,rsesek@chromium.org,bmeurer@chromium.org,lpy@chromium.org # Skipping CQ checks because original CL landed less than 1 days ago. NOPRESUBMIT=true NOTREECHECKS=true NOTRY=true BUG=v8:4984 Review-Url: https://codereview.chromium.org/1976603005 Cr-Commit-Position: refs/heads/master@{#36233}
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);
}
}
#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();
// Turning off the check for acceptable delays. Without this check,
// 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.
// const int kMaxTime = 35; // Maximum acceptable milliseconds for test.
// 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
} // namespace base
} // namespace v8