Add UMA for High Resolution Timer Usage

base/time/time_win.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.
 
 
 // Windows Timer Primer
 //
 // A good article:  http://www.ddj.com/windows/184416651
 // A good mozilla bug:  http://bugzilla.mozilla.org/show_bug.cgi?id=363258
 //
@@ skipping 77 matching lines @@
 
 // The two values that ActivateHighResolutionTimer uses to set the systemwide
 // timer interrupt frequency on Windows. It controls how precise timers are
 // but also has a big impact on battery life.
 const int kMinTimerIntervalHighResMs = 1;
 const int kMinTimerIntervalLowResMs = 4;
 // Track if kMinTimerIntervalHighResMs or kMinTimerIntervalLowResMs is active.
 bool g_high_res_timer_enabled = false;
 // How many times the high resolution timer has been called.
 uint32_t g_high_res_timer_count = 0;
+// Start time of the high resolution timer usage monitoring. This is needed
+// to calculate the usage as percentage of the total elapsed time.
+TimeTicks g_high_res_timer_usage_start;
+// The cumulative time the high resolution timer has been in use since
+// |g_high_res_timer_usage_start| moment.
+TimeDelta g_high_res_timer_usage;
+// Timestamp of the last activation change of the high resolution timer. This
+// is used to calculate the cumulative usage.
+TimeTicks g_high_res_timer_last_activation;
 // The lock to control access to the above two variables.
 base::Lock* GetHighResLock() {
   static auto* lock = new base::Lock();
   return lock;
 }
 
 // Returns the current value of the performance counter.
 uint64_t QPCNowRaw() {
   LARGE_INTEGER perf_counter_now = {};
   // According to the MSDN documentation for QueryPerformanceCounter(), this
@@ skipping 103 matching lines @@
   // can easily undo the effect (if necessary) when EnableHighResolutionTimer is
   // called.
   const uint32_t max = std::numeric_limits<uint32_t>::max();
 
   base::AutoLock lock(*GetHighResLock());
   UINT period = g_high_res_timer_enabled ? kMinTimerIntervalHighResMs
                                          : kMinTimerIntervalLowResMs;
   if (activating) {
     DCHECK_NE(g_high_res_timer_count, max);
     ++g_high_res_timer_count;
-    if (g_high_res_timer_count == 1)
+    if (g_high_res_timer_count == 1) {
+      g_high_res_timer_last_activation = TimeTicks::Now();
       timeBeginPeriod(period);
+    }
   } else {
     DCHECK_NE(g_high_res_timer_count, 0u);
     --g_high_res_timer_count;
-    if (g_high_res_timer_count == 0)
+    if (g_high_res_timer_count == 0) {
+      g_high_res_timer_usage +=
+          TimeTicks::Now() - g_high_res_timer_last_activation;
       timeEndPeriod(period);
+    }
   }
   return (period == kMinTimerIntervalHighResMs);
 }
 
 // static
 bool Time::IsHighResolutionTimerInUse() {
   base::AutoLock lock(*GetHighResLock());
   return g_high_res_timer_enabled && g_high_res_timer_count > 0;
 }
 
 // static
+void Time::ResetHighResolutionTimerUsage() {
+  base::AutoLock lock(*GetHighResLock());
+  g_high_res_timer_usage = TimeDelta();
+  g_high_res_timer_usage_start = TimeTicks::Now();
+  if (g_high_res_timer_count > 0)
+    g_high_res_timer_last_activation = g_high_res_timer_usage_start;
+}
+
+// static
+double Time::GetHighResolutionTimerUsage() {
+  base::AutoLock lock(*GetHighResLock());
+  TimeTicks now = TimeTicks::Now();
+  TimeDelta elapsed_time = now - g_high_res_timer_usage_start;
+  if (elapsed_time.is_zero()) {
+    // This is unexpected but possible if TimeTicks resolution is low and
+    // GetHighResolutionTimerUsage() is called promptly after
+    // ResetHighResolutionTimerUsage().
+    return 0.0;
+  }
+  TimeDelta used_time = g_high_res_timer_usage;
+  if (g_high_res_timer_count > 0) {
+    // If currently activated add the remainder of time since the last
+    // activation.
+    used_time += now - g_high_res_timer_last_activation;
+  }
+  return used_time.InMillisecondsF() / elapsed_time.InMillisecondsF() * 100;
+}
+
+// static
 bool Time::FromExploded(bool is_local, const Exploded& exploded, Time* time) {
   // Create the system struct representing our exploded time. It will either be
   // in local time or UTC.If casting from int to WORD results in overflow,
   // fail and return Time(0).
   SYSTEMTIME st;
   if (!SafeConvertToWord(exploded.year, &st.wYear) ||
       !SafeConvertToWord(exploded.month, &st.wMonth) ||
       !SafeConvertToWord(exploded.day_of_week, &st.wDayOfWeek) ||
       !SafeConvertToWord(exploded.day_of_month, &st.wDay) ||
       !SafeConvertToWord(exploded.hour, &st.wHour) ||
@@ skipping 419 matching lines @@
 TimeTicks TimeTicks::FromQPCValue(LONGLONG qpc_value) {
   return TimeTicks() + QPCValueToTimeDelta(qpc_value);
 }
 
 // TimeDelta ------------------------------------------------------------------
 
 // static
 TimeDelta TimeDelta::FromQPCValue(LONGLONG qpc_value) {
   return QPCValueToTimeDelta(qpc_value);
 }