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

base/time/time_win.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.
 
 
 // Windows Timer Primer
 //
 // A good article:  http://www.ddj.com/windows/184416651
 // A good mozilla bug:  http://bugzilla.mozilla.org/show_bug.cgi?id=363258
 //
@@ skipping 61 matching lines @@
 
 int64 CurrentWallclockMicroseconds() {
   FILETIME ft;
   ::GetSystemTimeAsFileTime(&ft);
   return FileTimeToMicroseconds(ft);
 }
 
 // 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();
 }
 
 }  // namespace
 
 // Time -----------------------------------------------------------------------
 
 // The internal representation of Time uses FILETIME, whose epoch is 1601-01-01
 // 00:00:00 UTC.  ((1970-1601)*365+89)*24*60*60*1000*1000, where 89 is the
@@ skipping 16 matching lines @@
   //
   // To make this work, we initialize the clock (initial_time) and the
   // counter (initial_ctr).  To compute the initial time, we can check
   // the number of ticks that have elapsed, and compute the delta.
   //
   // To avoid any drift, we periodically resync the counters to the system
   // clock.
   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) {
       InitializeClock();
       continue;
     }
 
-    return Time(elapsed + Time(initial_time));
+    return Time(elapsed + Time(start_time));
   }
 }
 
 // static
 Time Time::NowFromSystemTime() {
   // Force resync.
   InitializeClock();
   return Time(initial_time);
 }
 
@@ skipping 210 matching lines @@
 // reality due to bugs in BIOS or HAL on some, especially old computers.
 // With recent updates on HAL and newer BIOS, QPC is getting more reliable but
 // it should be used with caution.
 //
 // (3) System time. The system time provides a low-resolution (typically 10ms
 // to 55 milliseconds) time stamp but is comparatively less expensive to
 // retrieve and more reliable.
 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;
+
+    // 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();
   }
 
   bool IsUsingHighResClock() {
-    return ticks_per_second_ != 0.0;
-  }
-
-  void DisableHighResClock() {
-    ticks_per_second_ = 0.0;
+    return ticks_per_second_ != 0;
   }
 
   TimeDelta Now() {
     if (IsUsingHighResClock())
       return TimeDelta::FromMicroseconds(UnreliableNow());
 
     // Just fallback to the slower clock.
     return RolloverProtectedNow();
   }
 
@@ skipping 14 matching lines @@
     // overflow and precision issues.
     int64 whole_seconds = qpc_value / ticks_per_second_;
     int64 leftover_ticks = qpc_value - (whole_seconds * ticks_per_second_);
     int64 microseconds = (whole_seconds * Time::kMicrosecondsPerSecond) +
                          ((leftover_ticks * Time::kMicrosecondsPerSecond) /
                           ticks_per_second_);
     return microseconds;
   }
 
  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;
     QueryPerformanceCounter(&now);
     return QPCValueToMicroseconds(now.QuadPart);
   }
 
   // Get the number of microseconds since boot in a reliable fashion.
   int64 ReliableNow() {
     return RolloverProtectedNow().InMicroseconds();
@@ skipping 42 matching lines @@
   return old;
 }
 
 // static
 bool TimeTicks::SetNowIsHighResNowIfSupported() {
   if (!CPUReliablySupportsHighResTime()) {
     return false;
   }
 
   now_function = HighResNowWrapper;
+  InitializeClock();
   return true;
 }
 
 // static
 TimeTicks TimeTicks::Now() {
   return TimeTicks() + now_function();
 }
 
 // static
 TimeTicks TimeTicks::HighResNow() {
@@ skipping 38 matching lines @@
     return TimeTicks() + TimeDelta::FromMilliseconds(timeGetTime());
   }
 }
 
 // TimeDelta ------------------------------------------------------------------
 
 // static
 TimeDelta TimeDelta::FromQPCValue(LONGLONG qpc_value) {
   return TimeDelta(GetHighResNowSingleton()->QPCValueToMicroseconds(qpc_value));
 }