Fix CPU profiler deadlock on Windows + AMD CPU.

src/base/platform/time.cc

 // Copyright 2013 the V8 project 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 "src/base/platform/time.h"
 
 #if V8_OS_POSIX
 #include <fcntl.h>  // for O_RDONLY
 #include <sys/time.h>
 #include <unistd.h>
 #endif
 #if V8_OS_MACOSX
 #include <mach/mach_time.h>
 #endif
 
 #include <cstring>
 #include <ostream>
 
 #if V8_OS_WIN
+#include "src/base/atomicops.h"
 #include "src/base/lazy-instance.h"
 #include "src/base/win32-headers.h"
 #endif
 #include "src/base/cpu.h"
 #include "src/base/logging.h"
 #include "src/base/platform/platform.h"
 
 namespace v8 {
 namespace base {
 
@@ skipping 397 matching lines @@
 
   bool IsHighResolution() override { return true; }
 
  private:
   int64_t ticks_per_second_;
 };
 
 
 class RolloverProtectedTickClock final : public TickClock {
  public:
-  // We initialize rollover_ms_ to 1 to ensure that we will never
-  // return 0 from TimeTicks::HighResolutionNow() and TimeTicks::Now() below.
-  RolloverProtectedTickClock() : last_seen_now_(0), rollover_ms_(1) {}
+  RolloverProtectedTickClock() : rollover_(0) {}
   virtual ~RolloverProtectedTickClock() {}
 
   int64_t Now() 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.
+    // TimeTicks::Now() is called at least every 24 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
     // 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.
+    // We use a lock-free version because the sampler thread calls it
+    // while having the rest of the world stopped, that could cause a deadlock.
+    base::Atomic32 rollover = base::Acquire_Load(&rollover_);
+    uint32_t now = static_cast<uint32_t>(timeGetTime());
+    if ((now >> 31) != static_cast<uint32_t>(rollover & 1)) {
+      base::Release_CompareAndSwap(&rollover_, rollover, rollover + 1);
+      ++rollover;
     }
-    last_seen_now_ = now;
-    return (now + rollover_ms_) * Time::kMicrosecondsPerMillisecond;
+    uint64_t ms = (static_cast<uint64_t>(rollover) << 31) | now;
+    return static_cast<int64_t>(ms * Time::kMicrosecondsPerMillisecond);
   }
 
   bool IsHighResolution() override { return false; }
 
  private:
-  Mutex mutex_;
-  DWORD last_seen_now_;
-  int64_t rollover_ms_;
+  base::Atomic32 rollover_;
 };
 
 
 static LazyStaticInstance<RolloverProtectedTickClock,
                           DefaultConstructTrait<RolloverProtectedTickClock>,
                           ThreadSafeInitOnceTrait>::type tick_clock =
     LAZY_STATIC_INSTANCE_INITIALIZER;
 
 
 struct CreateHighResTickClockTrait {
@@ skipping 161 matching lines @@
 
 
 // static
 bool TimeTicks::KernelTimestampAvailable() {
   return kernel_tick_clock.Pointer()->Available();
 }
 
 #endif  // V8_OS_WIN
 
 } }  // namespace v8::base