Add UMA stats to get the quality of service of memory pressure handling scheme in ChromeOS.

base/chromeos/memory_pressure_observer_chromeos.cc

 // Copyright 2014 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/chromeos/memory_pressure_observer_chromeos.h"
 
 #include "base/message_loop/message_loop.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/process/process_metrics.h"
 #include "base/time/time.h"
 
 namespace base {
 
 namespace {
 
 // The time between memory pressure checks. While under critical pressure, this
 // is also the timer to repeat cleanup attempts.
 const int kMemoryPressureIntervalMs = 1000;
 
 // The time which should pass between two moderate memory pressure calls.
 const int kModerateMemoryPressureCooldownMs = 10000;
 
 // Number of event polls before the next moderate pressure event can be sent.
 const int kModerateMemoryPressureCooldown =
     kModerateMemoryPressureCooldownMs / kMemoryPressureIntervalMs;
 
 // Threshold constants to emit pressure events.
 const int kNormalMemoryPressureModerateThresholdPercent = 60;
 const int kNormalMemoryPressureCriticalThresholdPercent = 90;
 const int kAggressiveMemoryPressureModerateThresholdPercent = 35;
 const int kAggressiveMemoryPressureCriticalThresholdPercent = 70;
 
+// The number used to magnify the fraction of time spent in non critical state.
+const int kNonCriticalTimeFractionMagnification = 1000000;
+
 // Converts a |MemoryPressureThreshold| value into a used memory percentage for
 // the moderate pressure event.
 int GetModerateMemoryThresholdInPercent(
     MemoryPressureObserverChromeOS::MemoryPressureThresholds thresholds) {
   return thresholds == MemoryPressureObserverChromeOS::
                            THRESHOLD_AGGRESSIVE_CACHE_DISCARD ||
          thresholds == MemoryPressureObserverChromeOS::THRESHOLD_AGGRESSIVE
              ? kAggressiveMemoryPressureModerateThresholdPercent
              : kNormalMemoryPressureModerateThresholdPercent;
 }
 
 // Converts a |MemoryPressureThreshold| value into a used memory percentage for
 // the critical pressure event.
 int GetCriticalMemoryThresholdInPercent(
     MemoryPressureObserverChromeOS::MemoryPressureThresholds thresholds) {
   return thresholds == MemoryPressureObserverChromeOS::
                            THRESHOLD_AGGRESSIVE_TAB_DISCARD ||
          thresholds == MemoryPressureObserverChromeOS::THRESHOLD_AGGRESSIVE
              ? kAggressiveMemoryPressureCriticalThresholdPercent
              : kNormalMemoryPressureCriticalThresholdPercent;
 }
 
+// Computes the fraction of time spent in the non critical state. Multiple the
+// fraction with 1000000 to magnify the result for better comparison between

[Mr4D (OOO till 08-26), 2015/02/01 10:16:34]

Maybe:

Computes the by kNonCriticalTimeFractionMagnification scaled fraction of time
spent in non critical state vs. in critical + non critical state.

+// different memory management schemes.
+int GetNonCriticalTimeRatio(TimeDelta critical_delta,
+                            TimeDelta non_critical_delta) {
+  return (kNonCriticalTimeFractionMagnification *
+          non_critical_delta.InMilliseconds()) /
+         ((non_critical_delta + critical_delta).InMilliseconds());
+}
+
+void RecordNonCriticalTimeRatio(int non_critical_fraction) {
+  UMA_HISTOGRAM_COUNTS("ChromeOS.MemoryPressureHandleQuality.NonCriticalRatio",
+                       non_critical_fraction);
+}
+
 // Converts free percent of memory into a memory pressure value.
 MemoryPressureListener::MemoryPressureLevel GetMemoryPressureLevelFromFillLevel(
     int actual_fill_level,
     int moderate_threshold,
     int critical_threshold) {
   if (actual_fill_level < moderate_threshold)
     return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
   return actual_fill_level < critical_threshold
              ? MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE
              : MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
 }
 
 }  // namespace
 
 MemoryPressureObserverChromeOS::MemoryPressureObserverChromeOS(
     MemoryPressureThresholds thresholds)
     : current_memory_pressure_level_(
           MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE),
       moderate_pressure_repeat_count_(0),
       moderate_pressure_threshold_percent_(
           GetModerateMemoryThresholdInPercent(thresholds)),
       critical_pressure_threshold_percent_(
           GetCriticalMemoryThresholdInPercent(thresholds)),
+      non_critical_start_time_(TimeTicks::Now()),
+      critical_start_time_(TimeTicks::Now()),
       weak_ptr_factory_(this) {
   StartObserving();
 }
 
 MemoryPressureObserverChromeOS::~MemoryPressureObserverChromeOS() {
+  // Record the percentage for the last time.

[Mr4D (OOO till 08-26), 2015/02/01 10:16:34]

What about:

// Before shutting down send the quality of service statistics.

+  if (GetMemoryPressureLevelFromFillLevel(
+          GetUsedMemoryInPercent(), moderate_pressure_threshold_percent_,
+          critical_pressure_threshold_percent_) ==
+      MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
+    int fraction = GetNonCriticalTimeRatio(
+        TimeTicks::Now() - critical_start_time_,
+        critical_start_time_ - non_critical_start_time_);
+    RecordNonCriticalTimeRatio(fraction);
+  } else {
+    RecordNonCriticalTimeRatio(kNonCriticalTimeFractionMagnification);
+  }
+
   StopObserving();
 }
 
 void MemoryPressureObserverChromeOS::ScheduleEarlyCheck() {
   MessageLoop::current()->PostTask(
       FROM_HERE,
       Bind(&MemoryPressureObserverChromeOS::CheckMemoryPressure,
            weak_ptr_factory_.GetWeakPtr()));
 }
 
 void MemoryPressureObserverChromeOS::StartObserving() {
   timer_.Start(FROM_HERE,
                TimeDelta::FromMilliseconds(kMemoryPressureIntervalMs),
                Bind(&MemoryPressureObserverChromeOS::CheckMemoryPressure,
                     weak_ptr_factory_.GetWeakPtr()));
 }
 
 void MemoryPressureObserverChromeOS::StopObserving() {
   // If StartObserving failed, StopObserving will still get called.
   timer_.Stop();
 }
 
 void MemoryPressureObserverChromeOS::CheckMemoryPressure() {
   MemoryPressureListener::MemoryPressureLevel old_pressure =
       current_memory_pressure_level_;
   current_memory_pressure_level_ =
       GetMemoryPressureLevelFromFillLevel(GetUsedMemoryInPercent(),
                                           moderate_pressure_threshold_percent_,
                                           critical_pressure_threshold_percent_);
+
+  // Record the quality of service of memory pressure handling.
+  if (old_pressure != current_memory_pressure_level_) {
+    TimeTicks now = TimeTicks::Now();
+    if (old_pressure ==
+        MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
+      // When leaving the critical memory pressure, we compute the fraction of
+      // time spent in the non critical vs. the critical state. A larger value
+      // indicates a better management scheme.
+      int fraction = GetNonCriticalTimeRatio(
+          now - critical_start_time_,
+          critical_start_time_ - non_critical_start_time_);
+      RecordNonCriticalTimeRatio(fraction);
+      non_critical_start_time_ = now;
+    } else if (current_memory_pressure_level_ ==
+               MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
+      critical_start_time_ = now;
+    }
+  }
+
   // In case there is no memory pressure we do not notify.
   if (current_memory_pressure_level_ ==
       MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE) {
     return;
   }
   if (old_pressure == current_memory_pressure_level_) {
     // If the memory pressure is still at the same level, we notify again for a
     // critical level. In case of a moderate level repeat however, we only send
     // a notification after a certain time has passed.
     if (current_memory_pressure_level_ ==
@@ skipping 47 matching lines @@
   // Available memory is the sum of free, swap and easy reclaimable memory.
   int available_memory =
       info.free + info.swap_free / kSwapWeight + file_memory;
 
   DCHECK(available_memory < total_memory);
   int percentage = ((total_memory - available_memory) * 100) / total_memory;
   return percentage;
 }
 
 }  // namespace base