Save variables on stack to help determine why GPU watchdog is firing.

content/gpu/gpu_watchdog_thread.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.
 
 #include "content/gpu/gpu_watchdog_thread.h"
 
 #include <errno.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
+#include "base/debug/alias.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/power_monitor/power_monitor.h"
 #include "base/process/process.h"
 #include "base/single_thread_task_runner.h"
 #include "build/build_config.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 
@@ skipping 177 matching lines @@
   if (armed_ || suspended_)
     return;
 
   // Must set armed before posting the task. This task might be the only task
   // that will activate the TaskObserver on the watched thread and it must not
   // miss the false -> true transition.
   armed_ = true;
 
 #if defined(OS_WIN)
   arm_cpu_time_ = GetWatchedThreadTime();
+
+  QueryUnbiasedInterruptTime(&arm_interrupt_time_);
 #endif
 
   check_time_ = base::Time::Now();
+  check_timeticks_ = base::TimeTicks::Now();
   // Immediately after the computer is woken up from being suspended it might
   // be pretty sluggish, so allow some extra time before the next timeout.
   base::TimeDelta timeout = timeout_ * (after_suspend ? 3 : 1);
   suspension_timeout_ = check_time_ + timeout * 2;
 
   // Post a task to the monitored thread that does nothing but wake up the
   // TaskObserver. Any other tasks that are pending on the watched thread will
   // also wake up the observer. This simply ensures there is at least one.
   watched_message_loop_->task_runner()->PostTask(FROM_HERE,
                                                  base::Bind(&base::DoNothing));
@@ skipping 102 matching lines @@
   if (tty_file_ &&
       !fseek(tty_file_, 0, SEEK_SET) &&
       fread(tty_string, 1, 7, tty_file_)) {
     int tty_number = -1;
     int num_res = sscanf(tty_string, "tty%d", &tty_number);
     if (num_res == 1 && tty_number != 1)
       return;
   }
 #endif
 
+// Store variables so they're available in crash dumps to help determine the
+// cause of any hang.
+#if defined(OS_WIN)
+  ULONGLONG fire_interrupt_time;
+  QueryUnbiasedInterruptTime(&fire_interrupt_time);
+
+  // This is the time since the watchdog was armed, in 100ns intervals,
+  // ignoring time where the computer is suspended.
+  ULONGLONG interrupt_delay = fire_interrupt_time - arm_interrupt_time_;
+
+  base::debug::Alias(&interrupt_delay);
+  base::debug::Alias(&time_since_arm);
+
+  bool using_high_res_timer = base::Time::IsHighResolutionTimerInUse();
+  base::debug::Alias(&using_high_res_timer);
+#endif
+
+  base::Time current_time = base::Time::Now();
+  base::TimeTicks current_timeticks = base::TimeTicks::Now();
+  base::debug::Alias(&current_time);
+  base::debug::Alias(&current_timeticks);
+
   LOG(ERROR) << "The GPU process hung. Terminating after "
              << timeout_.InMilliseconds() << " ms.";
 
   // Deliberately crash the process to create a crash dump.
   *((volatile int*)0) = 0x1337;
 
   terminated = true;
 }
 
 #if defined(USE_X11)
@@ skipping 72 matching lines @@
   // not increasing. The other is where either the kernel hangs and never
   // returns to user level or where user level code
   // calls into kernel level repeatedly, giving up its quanta before it is
   // tracked, for example a loop that repeatedly Sleeps.
   return base::TimeDelta::FromMilliseconds(static_cast<int64_t>(
       (user_time64.QuadPart + kernel_time64.QuadPart) / 10000));
 }
 #endif
 
 }  // namespace content