Always use timeGetTime() for TimeTicks::Now() on Windows.

src/platform/time.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 25 matching lines @@
 
 #include <cstring>
 
 #include "checks.h"
 #include "cpu.h"
 #include "platform.h"
 #if V8_OS_WIN
 #include "win32-headers.h"
 #endif
 
-#if V8_OS_WIN
-// Prototype for GetTickCount64() procedure.
-extern "C" {
-typedef ULONGLONG (WINAPI *GETTICKCOUNT64PROC)(void);
-}
-#endif
-
 namespace v8 {
 namespace internal {
 
 TimeDelta TimeDelta::FromDays(int days) {
   return TimeDelta(days * Time::kMicrosecondsPerDay);
 }
 
 
 TimeDelta TimeDelta::FromHours(int hours) {
   return TimeDelta(hours * Time::kMicrosecondsPerHour);
@@ skipping 105 matching lines @@
 #endif  // V8_OS_POSIX
 
 
 #if V8_OS_WIN
 
 // We implement time using the high-resolution timers so that we can get
 // timeouts which are smaller than 10-15ms. To avoid any drift, we
 // periodically resync the internal clock to the system clock.
 class Clock V8_FINAL {
  public:
-  Clock() : initial_time_(CurrentWallclockTime()),
-            initial_ticks_(TimeTicks::Now()) {}
+  Clock() : initial_ticks_(GetSystemTicks()), initial_time_(GetSystemTime()) {}
 
   Time Now() {
-    // This must be executed under lock.
+    // Time between resampling the un-granular clock for this API (1 minute).
+    const TimeDelta kMaxElapsedTime = TimeDelta::FromMinutes(1);
+
     LockGuard<Mutex> lock_guard(&mutex_);
 
-    // Calculate the time elapsed since we started our timer.
-    TimeDelta elapsed = TimeTicks::Now() - initial_ticks_;
+    // Determine current time and ticks.
+    TimeTicks ticks = GetSystemTicks();
+    Time time = GetSystemTime();
 
-    // Check if we don't need to synchronize with the wallclock yet.
-    if (elapsed.InMicroseconds() <= kMaxMicrosecondsToAvoidDrift) {
-      return initial_time_ + elapsed;
+    // Check if we need to resynchronize due to backwards time

[Hannes Payer (out of office), 2013/10/02 11:27:25]

Move words up until you hit the 80 chars barrier. Moreover end sentence with a
".".

[Benedikt Meurer, 2013/10/02 12:27:46]

Done.

+    // change or elapsed time.

[Hannes Payer (out of office), 2013/10/02 11:27:25]

What do you mean here? Should it be "Check if we have to synchronize the clock"?

[Benedikt Meurer, 2013/10/02 12:27:46]

Done.

+    TimeDelta elapsed = ticks - initial_ticks_;
+    if (time < initial_time_ || elapsed > kMaxElapsedTime) {
+      initial_ticks_ = ticks;
+      initial_time_ = time;
+      return time;
     }
 
-    // Resynchronize with the wallclock.
-    initial_ticks_ = TimeTicks::Now();
-    initial_time_ = CurrentWallclockTime();
-    return initial_time_;
+    return initial_time_ + elapsed;
   }
 
   Time NowFromSystemTime() {
-    // This must be executed under lock.
     LockGuard<Mutex> lock_guard(&mutex_);
-
-    // Resynchronize with the wallclock.
-    initial_ticks_ = TimeTicks::Now();
-    initial_time_ = CurrentWallclockTime();
+    initial_ticks_ = GetSystemTicks();
+    initial_time_ = GetSystemTime();
     return initial_time_;
   }
 
  private:
-  // Time between resampling the un-granular clock for this API (1 minute).
-  static const int64_t kMaxMicrosecondsToAvoidDrift =
-      Time::kMicrosecondsPerMinute;
+  static TimeTicks GetSystemTicks() {
+    return TimeTicks::Now();
+  }
 
-  static Time CurrentWallclockTime() {
+  static Time GetSystemTime() {
     FILETIME ft;
     ::GetSystemTimeAsFileTime(&ft);
     return Time::FromFiletime(ft);
   }
 
   TimeTicks initial_ticks_;
   Time initial_time_;
   Mutex mutex_;
 };
 
 
-static LazyDynamicInstance<Clock,
-    DefaultCreateTrait<Clock>,
-    ThreadSafeInitOnceTrait>::type clock = LAZY_DYNAMIC_INSTANCE_INITIALIZER;
+static LazyStaticInstance<Clock,
+    DefaultConstructTrait<Clock>,
+    ThreadSafeInitOnceTrait>::type clock = LAZY_STATIC_INSTANCE_INITIALIZER;
 
 
 Time Time::Now() {
   return clock.Pointer()->Now();
 }
 
 
 Time Time::NowFromSystemTime() {
   return clock.Pointer()->NowFromSystemTime();
 }
@@ skipping 142 matching lines @@
   return static_cast<double>(us_) / kMicrosecondsPerMillisecond;
 }
 
 
 #if V8_OS_WIN
 
 class TickClock {
  public:
   virtual ~TickClock() {}
   virtual int64_t Now() = 0;
+  virtual bool IsHighResolution() =0;

[Hannes Payer (out of office), 2013/10/02 11:27:25]

space missing

[Benedikt Meurer, 2013/10/02 12:27:46]

Done.

 };
 
 
 // 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
@@ skipping 37 matching lines @@
     int64_t whole_seconds = now.QuadPart / ticks_per_second_;
     int64_t leftover_ticks = now.QuadPart % ticks_per_second_;
     int64_t ticks = (whole_seconds * Time::kMicrosecondsPerSecond) +
         ((leftover_ticks * Time::kMicrosecondsPerSecond) / ticks_per_second_);
 
     // Make sure we never return 0 here, so that TimeTicks::HighResNow()
     // will never return 0.
     return ticks + 1;
   }
 
+  virtual bool IsHighResolution() V8_OVERRIDE {
+    return true;
+  }
+
  private:
   int64_t ticks_per_second_;
 };
 
 
-// The GetTickCount64() API is what we actually want for the regular tick
-// clock, but this is only available starting with Windows Vista.
-class WindowsVistaTickClock V8_FINAL : public TickClock {
- public:
-  explicit WindowsVistaTickClock(GETTICKCOUNT64PROC func) : func_(func) {
-    ASSERT(func_ != NULL);
-  }
-  virtual ~WindowsVistaTickClock() {}
-
-  virtual int64_t Now() V8_OVERRIDE {
-    // Query the current ticks (in ms).
-    ULONGLONG tick_count_ms = (*func_)();
-
-    // Convert to microseconds (make sure to never return 0 here).
-    return (tick_count_ms * Time::kMicrosecondsPerMillisecond) + 1;
-  }
-
- private:
-  GETTICKCOUNT64PROC func_;
-};
-
-
 class RolloverProtectedTickClock V8_FINAL : public TickClock {
  public:
   // We initialize rollover_ms_ to 1 to ensure that we will never
   // return 0 from TimeTicks::HighResNow() and TimeTicks::Now() below.
   RolloverProtectedTickClock() : last_seen_now_(0), rollover_ms_(1) {}
   virtual ~RolloverProtectedTickClock() {}
 
   virtual int64_t Now() V8_OVERRIDE {
     LockGuard<Mutex> lock_guard(&mutex_);
     // We use timeGetTime() to implement TimeTicks::Now(), which rolls over
     // every ~49.7 days. We try to track rollover ourselves, which works if
     // TimeTicks::Now() is called at least every 49 days.
     // Note that we do not use GetTickCount() here, since timeGetTime() gives
     // more predictable delta values, as described here:
     // http://blogs.msdn.com/b/larryosterman/archive/2009/09/02/what-s-the-difference-between-gettickcount-and-timegettime.aspx

[Hannes Payer (out of office), 2013/10/02 11:27:25]

can we fix that link - 80 chars

[Benedikt Meurer, 2013/10/02 12:27:46]

As discussed offline, this is how we do it in other places.

+    //

[Hannes Payer (out of office), 2013/10/02 11:27:25]

remove that // with a newline

[Benedikt Meurer, 2013/10/02 12:27:46]

Done.

+    // timeGetTime() provides 1ms granularity when combined with
+    // timeBeginPeriod(). If the host application for V8 wants fast timers, it
+    // can use timeBeginPeriod() to increase the resolution.
     DWORD now = timeGetTime();
     if (now < last_seen_now_) {
       rollover_ms_ += V8_INT64_C(0x100000000);  // ~49.7 days.
     }
     last_seen_now_ = now;
     return (now + rollover_ms_) * Time::kMicrosecondsPerMillisecond;
   }
 
+  virtual bool IsHighResolution() V8_OVERRIDE {
+    return false;
+  }
+
  private:
   Mutex mutex_;
   DWORD last_seen_now_;
   int64_t rollover_ms_;
 };
 
 
-struct CreateTickClockTrait {
-  static TickClock* Create() {
-    // Try to load GetTickCount64() from kernel32.dll (available since Vista).
-    HMODULE kernel32 = ::GetModuleHandleA("kernel32.dll");
-    ASSERT(kernel32 != NULL);
-    FARPROC proc = ::GetProcAddress(kernel32, "GetTickCount64");
-    if (proc != NULL) {
-      return new WindowsVistaTickClock(
-          reinterpret_cast<GETTICKCOUNT64PROC>(proc));
-    }
-
-    // Fallback to the rollover protected tick clock.
-    return new RolloverProtectedTickClock;
-  }
-};
-
-
-static LazyDynamicInstance<TickClock,
-    CreateTickClockTrait,
+static LazyStaticInstance<RolloverProtectedTickClock,
+    DefaultConstructTrait<RolloverProtectedTickClock>,
     ThreadSafeInitOnceTrait>::type tick_clock =
-        LAZY_DYNAMIC_INSTANCE_INITIALIZER;
+        LAZY_STATIC_INSTANCE_INITIALIZER;
 
 
 struct CreateHighResTickClockTrait {
   static TickClock* Create() {
     // Check if the installed hardware supports a high-resolution performance
     // counter, and if not fallback to the low-resolution tick clock.
     LARGE_INTEGER ticks_per_second;
     if (!QueryPerformanceFrequency(&ticks_per_second)) {
       return tick_clock.Pointer();
     }
@@ skipping 24 matching lines @@
 }
 
 
 TimeTicks TimeTicks::HighResNow() {
   // Make sure we never return 0 here.
   TimeTicks ticks(high_res_tick_clock.Pointer()->Now());
   ASSERT(!ticks.IsNull());
   return ticks;
 }
 
+
+// static
+bool TimeTicks::IsHighResClockWorking() {
+  return high_res_tick_clock.Pointer()->IsHighResolution();
+}
+
 #else  // V8_OS_WIN
 
 TimeTicks TimeTicks::Now() {
   return HighResNow();
 }
 
 
 TimeTicks TimeTicks::HighResNow() {
   int64_t ticks;
 #if V8_OS_MACOSX
@@ skipping 21 matching lines @@
   int result = clock_gettime(CLOCK_MONOTONIC, &ts);
   ASSERT_EQ(0, result);
   USE(result);
   ticks = (ts.tv_sec * Time::kMicrosecondsPerSecond +
            ts.tv_nsec / Time::kNanosecondsPerMicrosecond);
 #endif  // V8_OS_MACOSX
   // Make sure we never return 0 here.
   return TimeTicks(ticks + 1);
 }
 
+
+// static
+bool TimeTicks::IsHighResClockWorking() {
+  return true;
+}
+
 #endif  // V8_OS_WIN
 
 } }  // namespace v8::internal