Add native QPC to base::Time* conversion on Windows.

base/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 326 matching lines @@
 // (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:
   static HighResNowSingleton* GetInstance() {
     return Singleton<HighResNowSingleton>::get();
   }
 
   bool IsUsingHighResClock() {
-    return ticks_per_microsecond_ != 0.0;
+    return ticks_per_second_ != 0.0;
   }
 
   void DisableHighResClock() {
-    ticks_per_microsecond_ = 0.0;
+    ticks_per_second_ = 0.0;
   }
 
   TimeDelta Now() {
     if (IsUsingHighResClock())
       return TimeDelta::FromMicroseconds(UnreliableNow());
 
     // Just fallback to the slower clock.
     return RolloverProtectedNow();
   }
 
   int64 GetQPCDriftMicroseconds() {
     if (!IsUsingHighResClock())
       return 0;
 
     // The static_cast<long> is needed as a hint to VS 2008 to tell it
     // which version of abs() to use. Other compilers don't seem to
     // need it, including VS 2010, but to keep code identical we use it
     // everywhere.
     // TODO(joi): Remove the hint if/when we no longer support VS 2008.
     return abs(static_cast<long>((UnreliableNow() - ReliableNow()) - skew_));
   }
 
+  int64 QPCValueToMicroseconds(LONGLONG qpc_value) {
+    if (ticks_per_second_)
+        return qpc_value * Time::kMicrosecondsPerSecond / ticks_per_second_;

[jar (doing other things), 2012/08/02 03:13:20]

nit: 2 character indent from start of "if"

+    return 0;
+  }
+
  private:
   HighResNowSingleton()
-    : ticks_per_microsecond_(0.0),
+    : ticks_per_second_(0),

[jbates, 2012/08/02 03:10:34]

what's the reason for changing to per_second? seems simpler to stick with
per_microsecond math?

[brianderson, 2012/08/02 19:04:14]

Using ticks per second, we are dividing by the actual value returned by
QueryPerformanceFrequency yielding the most accurate scaling.  The conversion to
microseconds in the end, however, causes us to overflow sooner (1e6 times more
often).

Using ticks per microsecond, we only overflow when the QPC overflows and we only
have to do a single division to convert.  However, we lose 20 bits (2^20 ~= 1e6)
of precision when scaling.

Using ticks per millisecond could be a compromise between the two extremes.  We
wouldn't overflow as often as ticks_per_second and we would only lose 10 bits
(2^10 ~= 1e3) of precision when scaling.

Assuming a 1 Ghz = 1e9 Hz QPC:
ticks_per_second will overflow in 2^(64-20) / 1e9 = 17592 seconds = 4.8 hrs.
ticks_per_millisconds will overflow 2^(64-10) / 1e9 = 18014398 seconds = 208
days.
ticks_per_microsecond will overflow 2^64 / 1e9 = 213504 days = 600 years.

Seems like we should stick to ticks_per_microsecond and hope the 20 bits of
precision lost is ok...

       skew_(0) {
     InitializeClock();
 
     // On Athlon X2 CPUs (e.g. model 15) QueryPerformanceCounter is
     // unreliable.  Fallback to low-res clock.
     base::CPU cpu;
     if (cpu.vendor_name() == "AuthenticAMD" && cpu.family() == 15)
       DisableHighResClock();
   }
 
   // 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_microsecond_ = static_cast<float>(ticks_per_sec.QuadPart) /
-      static_cast<float>(Time::kMicrosecondsPerSecond);
+    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 static_cast<int64>(now.QuadPart / ticks_per_microsecond_);
+    return now.QuadPart * Time::kMicrosecondsPerSecond / ticks_per_second_;

[jar (doing other things), 2012/08/02 03:13:20]

I think this is going to work ok (working with integers instead of a float)...
but I'm not sure.

Can you add a comment that suggests when we'll see an overflow in this integer
multiplication (that precedes the division)?

   }
 
   // Get the number of microseconds since boot in a reliable fashion.
   int64 ReliableNow() {
     return RolloverProtectedNow().InMicroseconds();
   }
 
   // Cached clock frequency -> microseconds. This assumes that the clock

[jar (doing other things), 2012/08/02 03:13:20]

Comment should be changed or removed.

   // frequency is faster than one microsecond (which is 1MHz, should be OK).
-  float ticks_per_microsecond_;  // 0 indicates QPF failed and we're broken.
+  int64 ticks_per_second_;  // 0 indicates QPF failed and we're broken.
   int64 skew_;  // Skew between lo-res and hi-res clocks (for debugging).
 
   friend struct DefaultSingletonTraits<HighResNowSingleton>;
 };
 
 }  // namespace
 
 // static
 TimeTicks::TickFunctionType TimeTicks::SetMockTickFunction(
     TickFunctionType ticker) {
@@ skipping 16 matching lines @@
 TimeTicks TimeTicks::NowFromSystemTraceTime() {
   return HighResNow();
 }
 
 // static
 int64 TimeTicks::GetQPCDriftMicroseconds() {
   return HighResNowSingleton::GetInstance()->GetQPCDriftMicroseconds();
 }
 
 // static
+TimeTicks TimeTicks::FromQPCValue(LONGLONG qpc_value) {
+  return TimeTicks(
+      HighResNowSingleton::GetInstance()->QPCValueToMicroseconds(qpc_value));
+}
+
+// static
 bool TimeTicks::IsHighResClockWorking() {
   return HighResNowSingleton::GetInstance()->IsUsingHighResClock();
 }
+
+// TimeDelta ------------------------------------------------------------------
+
+// static
+TimeDelta TimeDelta::FromQPCValue(LONGLONG qpc_value) {
+  return TimeDelta(
+      HighResNowSingleton::GetInstance()->QPCValueToMicroseconds(qpc_value));
+}