Time singleton and resolution changes.

base/time_win.cc

 // Copyright (c) 2006-2008 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"
 
 #pragma comment(lib, "winmm.lib")
 #include <windows.h>
 #include <mmsystem.h>
+
 #include "base/basictypes.h"
 #include "base/lock.h"
 #include "base/logging.h"
+#include "base/singleton.h"
 
 namespace {
 
 // From MSDN, FILETIME "Contains a 64-bit value representing the number of
 // 100-nanosecond intervals since January 1, 1601 (UTC)."
 int64 FileTimeToMicroseconds(const FILETIME& ft) {
   // Need to bit_cast to fix alignment, then divide by 10 to convert
   // 100-nanoseconds to milliseconds. This only works on little-endian
   // machines.
   return bit_cast<int64, FILETIME>(ft) / 10;
@@ skipping 92 matching lines @@
   exploded->month = st.wMonth;
   exploded->day_of_week = st.wDayOfWeek;
   exploded->day_of_month = st.wDay;
   exploded->hour = st.wHour;
   exploded->minute = st.wMinute;
   exploded->second = st.wSecond;
   exploded->millisecond = st.wMilliseconds;
 }
 
 // TimeTicks ------------------------------------------------------------------
+namespace {
 
-TimeTicks::TickFunction TimeTicks::tick_function_=
-    reinterpret_cast<TickFunction>(&timeGetTime);
+DWORD (__stdcall *tick_function)(void) = &timeGetTime;
 
-// static
-TimeTicks TimeTicks::Now() {
-  // Uses the multimedia timers on Windows to get a higher resolution clock.
-  // timeGetTime() provides a resolution which is variable depending on
-  // hardware and system configuration.  It can also be changed by other
-  // apps.  This class does not attempt to change the resolution of the
-  // timer, because we don't want to affect other applications.
-
-  // timeGetTime() should at least be accurate to ~5ms on all systems.
-  // timeGetTime() returns a 32-bit millisecond counter which has rollovers
-  // every ~49 days.
-  static DWORD last_tick_count = 0;
-  static int64 tick_rollover_accum = 0;
-  static Lock* tick_lock = NULL;  // To protect during rollover periods.
-
-  // Lazily create the lock we use.
-  if (!tick_lock) {
-    Lock* new_lock = new Lock;
-    if (InterlockedCompareExchangePointer(
-        reinterpret_cast<PVOID*>(&tick_lock), new_lock, NULL)) {
-      delete new_lock;
-    }
+// We use timeGetTime() to implement TimeTicks::Now().  This can be problematic
+// because it returns the number of milliseconds since Windows has started,
+// which will roll over the 32-bit value every ~49 days.  We try to track
+// rollover ourselves, which works if TimeTicks::Now() is called at least every
+// 49 days.
+class NowSingleton {
+ public:
+  NowSingleton()
+      : rollover_(TimeDelta::FromMilliseconds(0)), last_seen_(0) {
+    // Request a resolution of 1ms from timeGetTime().  This can have some
+    // consequences on other applications (see MSDN), but we've found that it
+    // is very common in other applications (Flash, Media Player, etc), so it
+    // is not really a dangerous thing to do.  We need this because the default
+    // resolution of ~15ms is much too low for accurate timing and timers.
+    ::timeBeginPeriod(1);
   }
 
-  // Atomically protect the low and high 32bit values for time.
-  // In the future we may be able to optimize with
-  // InterlockedCompareExchange64, but that doesn't work on XP.
-  DWORD tick_count;
-  int64 rollover_count;
-  {
-    AutoLock lock(*tick_lock);
-    tick_count = tick_function_();
-    if (tick_count < last_tick_count)
-      tick_rollover_accum += GG_INT64_C(0x100000000);
-
-    last_tick_count = tick_count;
-    rollover_count = tick_rollover_accum;
+  ~NowSingleton() {
+    ::timeEndPeriod(1);
   }
 
-  // GetTickCount returns milliseconds, we want microseconds.
-  return TimeTicks((tick_count + rollover_count) *
-                   Time::kMicrosecondsPerMillisecond);
-}
+  TimeDelta Now() {
+    AutoLock locked(lock_);
+    // We should hold the lock while calling tick_function to make sure that
+    // we keep our last_seen_ stay correctly in sync.
+    DWORD now = tick_function();
+    if (now < last_seen_)
+      rollover_ += TimeDelta::FromMilliseconds(0x100000000I64);  // ~49.7 days.
+    last_seen_ = now;
+    return TimeDelta::FromMilliseconds(now) + rollover_;
+  }
+
+ private:
+  Lock lock_;  // To protected last_seen_ and rollover_.
+  TimeDelta rollover_;  // Accumulation of time lost due to rollover.
+  DWORD last_seen_;  // The last timeGetTime value we saw, to detect rollover.
+
+  DISALLOW_COPY_AND_ASSIGN(NowSingleton);
+};
 
 // Overview of time counters:
 // (1) CPU cycle counter. (Retrieved via RDTSC)
 // The CPU counter provides the highest resolution time stamp and is the least
 // expensive to retrieve. However, the CPU counter is unreliable and should not
 // be used in production. Its biggest issue is that it is per processor and it
 // is not synchronized between processors. Also, on some computers, the counters
 // will change frequency due to thermal and power changes, and stop in some
 // states.
 //
 // (2) QueryPerformanceCounter (QPC). The QPC counter provides a high-
 // resolution (100 nanoseconds) time stamp but is comparatively more expensive
 // to retrieve. What QueryPerformanceCounter actually does is up to the HAL.
 // (with some help from ACPI).
 // According to http://blogs.msdn.com/oldnewthing/archive/2005/09/02/459952.aspx
 // in the worst case, it gets the counter from the rollover interrupt on the
 // programmable interrupt timer. In best cases, the HAL may conclude that the
 // RDTSC counter runs at a constant frequency, then it uses that instead. On
 // multiprocessor machines, it will try to verify the values returned from
 // RDTSC on each processor are consistent with each other, and apply a handful
 // of workarounds for known buggy hardware. In other words, QPC is supposed to
 // give consistent result on a multiprocessor computer, but it is unreliable in
 // 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 UnreliableHighResNowSingleton {
+ public:
+  UnreliableHighResNowSingleton() : ticks_per_microsecond_(0) {
+    LARGE_INTEGER ticks_per_sec = {0};
+    if (!QueryPerformanceFrequency(&ticks_per_sec))
+      return;  // Broken, we don't guarantee this function works.
+    ticks_per_microsecond_ =
+        ticks_per_sec.QuadPart / Time::kMicrosecondsPerSecond;
+  }
+
+  bool IsBroken() {
+    return ticks_per_microsecond_ == 0;
+  }
+
+  TimeDelta Now() {
+    LARGE_INTEGER now;
+    QueryPerformanceCounter(&now);
+    return TimeDelta::FromMicroseconds(now.QuadPart / ticks_per_microsecond_);
+  }
+
+ private:
+  // Cached clock frequency -> microseconds. This assumes that the clock
+  // frequency is faster than one microsecond (which is 1MHz, should be OK).
+  int64 ticks_per_microsecond_;  // 0 indicates QPF failed and we're broken.
+
+  DISALLOW_COPY_AND_ASSIGN(UnreliableHighResNowSingleton);
+};
+
+}  // namespace
+
+// static
+TimeTicks::TickFunctionType TimeTicks::SetMockTickFunction(
+    TickFunctionType ticker) {
+  TickFunctionType old = tick_function;
+  tick_function = ticker;
+  return old;
+}
+
+// static
+TimeTicks TimeTicks::Now() {
+  return TimeTicks() + Singleton<NowSingleton>::get()->Now();
+}
 
 // static
 TimeTicks TimeTicks::UnreliableHighResNow() {
-  // Cached clock frequency -> microseconds. This assumes that the clock
-  // frequency is faster than one microsecond (which is 1MHz, should be OK).
-  static int64 ticks_per_microsecond = 0;
+  UnreliableHighResNowSingleton* now =
+      Singleton<UnreliableHighResNowSingleton>::get();
 
-  if (ticks_per_microsecond == 0) {
-    LARGE_INTEGER ticks_per_sec = { 0, 0 };
-    if (!QueryPerformanceFrequency(&ticks_per_sec))
-      return TimeTicks(0);  // Broken, we don't guarantee this function works.
-    ticks_per_microsecond =
-        ticks_per_sec.QuadPart / Time::kMicrosecondsPerSecond;
+  if (now->IsBroken()) {
+    NOTREACHED() << "QueryPerformanceCounter is broken.";
+    return TimeTicks(0);
   }
 
-  LARGE_INTEGER now;
-  QueryPerformanceCounter(&now);
-  return TimeTicks(now.QuadPart / ticks_per_microsecond);
+  return TimeTicks() + now->Now();
 }
-