Initialize the now_funciton to the HighResNowWrapper in case High Res is supported

base/time/time_win.cc

Index: base/time/time_win.cc
diff --git a/base/time/time_win.cc b/base/time/time_win.cc
index 5fa899d1f97f69be69d1df65ba854565d7240b53..86cbde86082911be318ca432f97c05a4dd197969 100644
--- a/base/time/time_win.cc
+++ b/base/time/time_win.cc
@@ -79,10 +79,22 @@ int64 CurrentWallclockMicroseconds() {
 // Time between resampling the un-granular clock for this API.  60 seconds.
 const int kMaxMillisecondsToAvoidDrift = 60 * Time::kMillisecondsPerSecond;
 
-int64 initial_time = 0;
+// The ticks at initialization.
 TimeTicks initial_ticks;
 
+// The time at initialization.
+int64 initial_time = 0;
+
+// Lock protecting initial_time and initial_ticks.
+// Note: this is a global object, and we usually avoid these. However, the time
+// code is low-level, and we don't want to use Singletons here (it would be too

[Nico, 2014/08/15 23:17:38]

(fwiw, on linux or mac, "low-level" isn't an excuse. We don't allow static
initializers on mac and linux, period. Mac is at 0 static initializers, linux is
close to it.

However, on Windows we don't track static initializers, and we haven't removed
many of them, look e.g. for "Wexit-time-destructors" in
http://build.chromium.org/p/chromium.fyi/builders/Cr%20Win%20Clang/builds/94/...

The cost of static initializers isn't the cost in running the code, but that it
causes this page of code paged in during startup, and executables are often laid
out in a way that paging in the code bits with static initializers causes many
disk cache misses.)

[willchan no longer on Chromium, 2014/08/15 23:20:19]

This is very true. But what's the alternative? Do we always go through the
synchronization required to access a LazyInstance after process startup? For
something called as frequently as time code, it's not obvious to me that that's
the right tradeoff to make. I'd love to hear opinions or other alternatives
though.

+// easy to use a Singleton without even knowing it, and that may lead to many
+// gotchas). Its impact on startup time should be negligible due to low-level
+// nature of time code.
+base::Lock initialize_clock_lock;
+
 void InitializeClock() {
+  base::AutoLock locked(initialize_clock_lock);

[M-A Ruel, 2014/08/16 00:40:14]

Because I'm a nice guy, here's the code you actually want. Please pardon my
rusty C++;

// Yes, it's a good use of volatile.
volatile int64 initial_ticks = 0;
volatile int64 initial_time = 0;

// Sets the clock only if it was set to 0.
void InitializeClock() {
  MemoryBarrier();
  if (initial_time != 0) {
    return;
  }
  for (;;) {
    int64 ticks = TimeTicks::Now();
    int time = CurrentWallclockMicroseconds();
    if (0 != InterlockedCompareExchange64(&initial_ticks, ticks, 0) {
      // We lost.
      return;
    }
    if (0 != InterlockedCompareExchange64(&initial_time, time, 0) {
      // That's disturbing but nothing can be done.
    }
  }
}

(int64, int64) ReadClock() {
  for (;;) {
    MemoryBarrier();
    int64 time = initial_time;
    int64 ticks = initial_ticks;
    MemoryBarrier();
    int64 time2 = initial_time;
    int64 ticks2 = initial_ticks;
    if (time == time2 && ticks == ticks2) {
      return time, ticks; // Remind me it's not Go.
    }
  }
}

// Forcibly set the clock.
void SetClock() {
  for (;;) {
    int64 ticks = TimeTicks::Now();
    int time = CurrentWallclockMicroseconds();
    MemoryBarrier();
    int64 old_time = initial_time;
    int64 old_ticks = initial_ticks;
    if (old_ticks != InterlockedCompareExchange64(&initial_ticks, ticks,
old_ticks) {
      continue;
    }
    if (old_time != InterlockedCompareExchange64(&initial_time, time, old_time)
{
      // That's disturbing but nothing can be done.
      continue;
    }
    return;
  }
}

Given with no guarantee whatsoever. May break, kill or cause a thermonuclear
war. InterlockedCompareExchange64() IIRC is fine because we already require
SSE2.

If you cared about perf, your wouldn't use a class for TimeTicks and only use
raw int64. But that's C++, not Go, so you can't do strongly typed typedef. Oh
well. :)

   initial_ticks = TimeTicks::Now();
   initial_time = CurrentWallclockMicroseconds();
 }
@@ -119,8 +131,16 @@ Time Time::Now() {
   while (true) {
     TimeTicks ticks = TimeTicks::Now();
 
+    int64 start_time = 0;
+    TimeTicks start_ticks;
+    {
+        base::AutoLock locked(initialize_clock_lock);
+        start_time = initial_time;
+        start_ticks = initial_ticks;
+    }
+
     // Calculate the time elapsed since we started our timer
-    TimeDelta elapsed = ticks - initial_ticks;
+    TimeDelta elapsed = ticks - start_ticks;
 
     // Check if enough time has elapsed that we need to resync the clock.
     if (elapsed.InMilliseconds() > kMaxMillisecondsToAvoidDrift) {
@@ -128,7 +148,7 @@ Time Time::Now() {
       continue;
     }
 
-    return Time(elapsed + Time(initial_time));
+    return Time(elapsed + Time(start_time));
   }
 }
 
@@ -359,21 +379,24 @@ bool IsBuggyAthlon(const base::CPU& cpu) {
 class HighResNowSingleton {
  public:
   HighResNowSingleton()
-    : ticks_per_second_(0),
-      skew_(0) {
-    InitializeClock();
+      : ticks_per_second_(0),
+        skew_(0) {
 
     base::CPU cpu;
     if (IsBuggyAthlon(cpu))
-      DisableHighResClock();
-  }
+      return;
 
-  bool IsUsingHighResClock() {
-    return ticks_per_second_ != 0.0;
+    // Synchronize the QPC clock with GetSystemTimeAsFileTime.
+    LARGE_INTEGER ticks_per_sec = {0};
+    if (!QueryPerformanceFrequency(&ticks_per_sec))
+      return; // QPC is not available.
+    ticks_per_second_ = ticks_per_sec.QuadPart;
+
+    skew_ = UnreliableNow() - ReliableNow();
   }
 
-  void DisableHighResClock() {
-    ticks_per_second_ = 0.0;
+  bool IsUsingHighResClock() {
+    return ticks_per_second_ != 0;
   }
 
   TimeDelta Now() {
@@ -408,16 +431,6 @@ class HighResNowSingleton {
   }
 
  private:
-  // Synchronize the QPC clock with GetSystemTimeAsFileTime.
-  void InitializeClock() {
-    LARGE_INTEGER ticks_per_sec = {0};
-    if (!QueryPerformanceFrequency(&ticks_per_sec))
-      return;  // Broken, we don't guarantee this function works.
-    ticks_per_second_ = ticks_per_sec.QuadPart;
-
-    skew_ = UnreliableNow() - ReliableNow();
-  }
-
   // Get the number of microseconds since boot in an unreliable fashion.
   int64 UnreliableNow() {
     LARGE_INTEGER now;
@@ -480,6 +493,7 @@ bool TimeTicks::SetNowIsHighResNowIfSupported() {
   }
 
   now_function = HighResNowWrapper;
+  InitializeClock();
   return true;
 }