Add interface to system trace clock.

base/time_unittest.cc

 // Copyright (c) 2012 The Chromium 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 "base/time.h"
 
 #include <time.h>
 
 #include "base/compiler_specific.h"
 #include "base/threading/platform_thread.h"
@@ skipping 485 matching lines @@
 
     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(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));
   EXPECT_TRUE(TimeDelta::FromMinutes(2) == TimeDelta::FromSeconds(120));
   EXPECT_TRUE(TimeDelta::FromSeconds(2) == TimeDelta::FromMilliseconds(2000));
   EXPECT_TRUE(TimeDelta::FromMilliseconds(2) ==
               TimeDelta::FromMicroseconds(2000));
   EXPECT_EQ(13, TimeDelta::FromDays(13).InDays());
   EXPECT_EQ(13, TimeDelta::FromHours(13).InHours());
   EXPECT_EQ(13, TimeDelta::FromMinutes(13).InMinutes());
@@ skipping 38 matching lines @@
   exploded.minute = 0;
   exploded.second = 0;
   exploded.millisecond = 0;
   Time t = Time::FromUTCExploded(exploded);
   // Unix 1970 epoch.
   EXPECT_EQ(GG_INT64_C(11644473600000000), t.ToInternalValue());
 
   // We can't test 1601 epoch, since the system time functions on Linux
   // only compute years starting from 1900.
 }