Add interface to system trace clock.

base/time_unittest.cc

Index: base/time_unittest.cc
diff --git a/base/time_unittest.cc b/base/time_unittest.cc
index 9823147a33dac223d224726b3c988676cf8e7be6..302b8f1d3d2764953be858788d3a3fa010d449c5 100644
--- a/base/time_unittest.cc
+++ b/base/time_unittest.cc
@@ -503,6 +503,45 @@ TEST(TimeTicks, HighResNow) {
   EXPECT_TRUE(success);
 }
 
+TEST(TimeTicks, NowFromSystemTraceTime) {
+#if defined(OS_WIN)
+  // HighResNow doesn't work on some systems.  Since the product still works
+  // even if it doesn't work, it makes this entire test questionable.
+  if (!TimeTicks::IsHighResClockWorking())
+    return;
+#endif
+
+  // Why do we loop here?
+  // We're trying to measure that intervals increment in a VERY small amount
+  // of time --  less than 15ms.  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.
+
+  const int kTargetGranularityUs = 15000;  // 15ms

[jar (doing other things), 2012/04/27 22:50:18]

Ordinary system clocks can be set to run faster than 15ms.  It is common for
multi-media folks to set it down to closer to a few ms.  Don't you expect your
clock to reveal intervals shorter than 1ms?

[Sam Leffler, 2012/04/27 22:56:07]

This is c&p of the HighRes test; I did not write this.

[jar (doing other things), 2012/04/30 22:05:57]

I see now.  I read this as new code, and made comments, but it appears you cut
and paste the previous test to create this one.

Rather than cutting/pasting, how about factoring out the common code, and using
it?

For example, you can pass in the pointer to the function you want tested into a
shared routine.

Replication of code tends to just grow and grow in these unit tests... so shared
code is a good thing.

[Sam Leffler, 2012/04/30 22:47:58]

Done.

+
+  bool success = false;
+  int retries = 100;  // Arbitrary.

[jar (doing other things), 2012/04/27 22:50:18]

100 sounds plausible.... but it is always nice to maximally avoid flakiness
(false failures).  You can set this really high, and then, if you take more than
about 3 or 5 minutes (don't recall the amount), then your test will fail for
"taking too long."  This creates a "design for success," as this will generally
complete really fast, and you'll be sure you are working.  When it fails, it
should be a big surprise, and we don't mind taking a long time.

[Sam Leffler, 2012/04/27 22:56:07]

I don't see the HighRes test failing so think this is ok.  The new clock source
doesn't (so far) provide any significantly different/better properties than that
clock source and on all but cros is idential.

+  TimeDelta delta;
+  while (!success && retries--) {
+    TimeTicks ticks_start = TimeTicks::NowFromSystemTraceTime();
+    // Loop until we can detect that the clock has changed.  Non-HighRes timers
+    // will increment in chunks, e.g. 15ms.  By spinning until we see a clock
+    // change, we detect the minimum time between measurements.
+    do {
+      delta = TimeTicks::NowFromSystemTraceTime() - ticks_start;
+    } while (delta.InMilliseconds() == 0);

[jar (doing other things), 2012/04/27 22:50:18]

Why don't you look for any change?  Why does the millisecond value have to have
changed?? Why not:
while (delta != TimeTicks())

Is there some other interesting characteristic you're watching for?

The above test will only watch for sub-granularity changes *when* we cross a
millisecond boundary.

[Sam Leffler, 2012/04/27 22:56:07]

Again, this is just the existing HighRes test; if you want me to write an
entirely new test I can do that.

+
+    if (delta.InMicroseconds() <= kTargetGranularityUs)
+      success = true;
+  }
+
+  // In high resolution mode, we expect to see the clock increment
+  // in intervals less than 15ms.
+  EXPECT_TRUE(success);
+}
+
 TEST(TimeDelta, FromAndIn) {
   EXPECT_TRUE(TimeDelta::FromDays(2) == TimeDelta::FromHours(48));
   EXPECT_TRUE(TimeDelta::FromHours(3) == TimeDelta::FromMinutes(180));