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

base/time_win.cc

Index: base/time_win.cc
diff --git a/base/time_win.cc b/base/time_win.cc
index 71c914da29dabe75003d9e83172269d3ac72a717..1efd287a092a0cb7ce0df5a1b1bad37bda5852f5 100644
--- a/base/time_win.cc
+++ b/base/time_win.cc
@@ -344,11 +344,11 @@ class HighResNowSingleton {
   }
 
   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() {
@@ -371,9 +371,15 @@ class HighResNowSingleton {
     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();
 
@@ -389,8 +395,7 @@ class HighResNowSingleton {
     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();
   }
@@ -399,7 +404,7 @@ class HighResNowSingleton {
   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.
@@ -409,7 +414,7 @@ class HighResNowSingleton {
 
   // 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>;
@@ -446,6 +451,20 @@ int64 TimeTicks::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));
+}