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;
@@ skipping 49 matching lines @@
 
 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.
+  if (GetMemoryPressureLevelFromFillLevel(
+          GetUsedMemoryInPercent(), moderate_pressure_threshold_percent_,
+          critical_pressure_threshold_percent_) ==
+      MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
+    non_critical_delta_ = critical_start_time_ - non_critical_start_time_;
+    critical_delta_ = TimeTicks::Now() - critical_start_time_;
+    int percentage = (100 * non_critical_delta_.InMilliseconds()) /
+                     ((non_critical_delta_ + critical_delta_).InMilliseconds());

[Mr4D (OOO till 08-26), 2015/01/29 08:17:53]

For line 90 - 93 I would create a function which can be called from here and
from line 135. It would return then an int value which is the percentage.

I would then create a static function which writes the UMA stat and which gets
an int. Pass either the retrieved number or 100. (this reduces the number of
this macro expansion and the danger of typos).

[xdai1, 2015/01/31 00:01:39]

Why should the function that writes the UMA stat be static? 

+    UMA_HISTOGRAM_PERCENTAGE(
+        "ChromeOS.MemoryPressureHandleQuality.NonCriticalRatio", percentage);
+  } else {
+    UMA_HISTOGRAM_PERCENTAGE(
+        "ChromeOS.MemoryPressureHandleQuality.NonCriticalRatio", 100);
+  }
+
   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 quality of service of memory pressure handling scheme in ChromeOS.

[Mr4D (OOO till 08-26), 2015/01/29 08:17:53]

Maybe:

// Record the quality of service for memory pressure handling.

?

[xdai1, 2015/01/31 00:01:39]

Done.

+  if (old_pressure != current_memory_pressure_level_) {
+    if (old_pressure ==
+        MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
+      critical_delta_ = TimeTicks::Now() - critical_start_time_;

[Mr4D (OOO till 08-26), 2015/01/29 08:17:53]

Note: As stated in the header file we do not need the delta variables inside the
data structure. 

Suggestion: You call Now() twice. It is better to call it only once and use that
value in both locations since time can pass between the two calls, which would
then introduce a gap / error.

[xdai1, 2015/01/31 00:01:39]

Done.

+      non_critical_start_time_ = TimeTicks::Now();
+

[Mr4D (OOO till 08-26), 2015/01/29 08:17:53]

What about: 

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.

?

[xdai1, 2015/01/31 00:01:39]

Done.

+      // We compute the percentage of the system stayed in non-critical memory
+      // pressure state each time when the system left the critical memory
+      // pressure state. The larger the percentage is, the better the memory
+      // pressure handling scheme is.
+      int percentage =
+          (100 * non_critical_delta_.InMilliseconds()) /
+          ((non_critical_delta_ + critical_delta_).InMilliseconds());
+      UMA_HISTOGRAM_PERCENTAGE(
+          "ChromeOS.MemoryPressureHandleQuality.NonCriticalRatio", percentage);
+
+    } else if (current_memory_pressure_level_ ==
+               MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
+      non_critical_delta_ = TimeTicks::Now() - non_critical_start_time_;
+      critical_start_time_ = TimeTicks::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