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)),
+      time_non_critical_pressure_(0),
+      time_critical_pressure_(0),
       weak_ptr_factory_(this) {
   StartObserving();
 }
 
 MemoryPressureObserverChromeOS::~MemoryPressureObserverChromeOS() {
+  // Record quality of service of memory pressure handling scheme in ChromeOS.
+  // 1 day (approximately in Millisecond) is a good enough upper limit.
+  const int kMaxQualityOfPressureHandleService = 100000000;
+  if (time_critical_pressure_ != 0) {
+    int ratio = time_non_critical_pressure_ / time_critical_pressure_;
+    ratio = (ratio > kMaxQualityOfPressureHandleService)
+                ? kMaxQualityOfPressureHandleService
+                : ratio;
+    UMA_HISTOGRAM_CUSTOM_COUNTS(
+        "ChromeOS.MemoryPressureHandleQuality.TimeRatio", ratio,
+        kMemoryPressureIntervalMs, kMaxQualityOfPressureHandleService, 50);
+  } else {
+    UMA_HISTOGRAM_CUSTOM_COUNTS(
+        "ChromeOS.MemoryPressureHandleQuality.TimeRatio",
+        kMaxQualityOfPressureHandleService, kMemoryPressureIntervalMs,
+        kMaxQualityOfPressureHandleService, 50);
+  }
+  time_non_critical_pressure_ = 0;
+  time_critical_pressure_ = 0;
   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_);
+
+  if (current_memory_pressure_level_ ==
+      MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL)

[Mr4D (OOO till 08-26), 2015/01/27 13:49:42]

Instead of adding the ms value here, you should remember the time stamp at event
time and subtract them to get the real time delta.

Reason:
The time between events is "roughly" what we are asking for, but in the end the
task scheduler and many other factors decide when / how this is called and the
error is cumulative.

+    time_critical_pressure_ += kMemoryPressureIntervalMs;
+  else
+    time_non_critical_pressure_ += kMemoryPressureIntervalMs;
+
   // 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