Create MemoryPressureStatsCollector.

components/memory_pressure/memory_pressure_stats_collector.cc

+// Copyright 2015 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 "components/memory_pressure/memory_pressure_stats_collector.h"
+
+#include "base/metrics/histogram.h"
+#include "base/time/tick_clock.h"
+
+namespace memory_pressure {
+
+namespace {
+
+using MemoryPressureLevel = MemoryPressureListener::MemoryPressureLevel;
+
+// Converts a memory pressure level to an UMA enumeration value.
+MemoryPressureLevelUMA MemoryPressureLevelToUmaEnumValue(
+    MemoryPressureLevel level) {
+  switch (level) {
+    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE:
+      return UMA_MEMORY_PRESSURE_LEVEL_NONE;
+    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE:
+      return UMA_MEMORY_PRESSURE_LEVEL_MODERATE;
+    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL:
+      return UMA_MEMORY_PRESSURE_LEVEL_CRITICAL;
+  }
+  NOTREACHED();
+  return UMA_MEMORY_PRESSURE_LEVEL_NONE;
+}
+
+// Converts an UMA enumeration value to a memory pressure level.
+MemoryPressureLevel MemoryPressureLevelFromUmaEnumValue(
+    MemoryPressureLevelUMA level) {
+  switch (level) {
+    case UMA_MEMORY_PRESSURE_LEVEL_NONE:
+      return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
+    case UMA_MEMORY_PRESSURE_LEVEL_MODERATE:
+      return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE;
+    case UMA_MEMORY_PRESSURE_LEVEL_CRITICAL:
+      return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
+    case UMA_MEMORY_PRESSURE_LEVEL_COUNT:
+      NOTREACHED();
+      break;
+  }
+  NOTREACHED();
+  return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
+}
+
+// Converts a pressure state change to an UMA enumeration value.
+MemoryPressureLevelChangeUMA MemoryPressureLevelChangeToUmaEnumValue(
+    MemoryPressureLevel old_level,
+    MemoryPressureLevel new_level) {
+  switch (old_level) {
+    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE: {
+      if (new_level == MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE)
+        return UMA_MEMORY_PRESSURE_LEVEL_CHANGE_NONE_TO_MODERATE;
+      if (new_level == MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL)
+        return UMA_MEMORY_PRESSURE_LEVEL_CHANGE_NONE_TO_CRITICAL;
+      // Should never happen. Fall through to the NOTREACHED below.

[grt (UTC plus 2), 2015/09/08 19:22:10]

nit: to me, "fall through" means fall through to the next "case" block. how
about:
      break;  // Should never happen; handled by the NOTREACHED below.

[chrisha, 2015/09/08 19:57:53]

Done.

+      break;
+    }
+    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE: {
+      if (new_level == MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE)
+        return UMA_MEMORY_PRESSURE_LEVEL_CHANGE_MODERATE_TO_NONE;
+      if (new_level == MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL)
+        return UMA_MEMORY_PRESSURE_LEVEL_CHANGE_MODERATE_TO_CRITICAL;
+      // Should never happen. Fall through to the NOTREACHED below.
+      break;
+    }
+    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL: {
+      if (new_level == MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE)
+        return UMA_MEMORY_PRESSURE_LEVEL_CHANGE_CRITICAL_TO_MODERATE;
+      if (new_level == MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE)
+        return UMA_MEMORY_PRESSURE_LEVEL_CHANGE_CRITICAL_TO_MODERATE;
+      // Should never happen. Fall through to the NOTREACHED below.
+      break;
+    }
+  }
+  NOTREACHED();
+  return UMA_MEMORY_PRESSURE_LEVEL_CHANGE_NONE_TO_MODERATE;
+}
+
+}  // namespace
+
+MemoryPressureStatsCollector::MemoryPressureStatsCollector(
+    base::TickClock* tick_clock)
+    : tick_clock_(tick_clock),
+      last_pressure_level_(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE) {
+}
+
+void MemoryPressureStatsCollector::UpdateStatistics(
+    MemoryPressureLevel current_pressure_level) {
+  base::TimeTicks now = tick_clock_->NowTicks();
+
+  // Special case: first call to the collector. Observations have just started
+  // so there's nothing to report.
+  if (last_update_time_.is_null()) {
+    last_pressure_level_ = current_pressure_level;
+    last_update_time_ = now;
+    return;
+  }
+
+  // If the pressure level has transitioned then report this.
+  if (last_pressure_level_ != current_pressure_level)
+    ReportLevelChange(last_pressure_level_, current_pressure_level);
+
+  // Increment the appropriate cumulative bucket.
+  int index = MemoryPressureLevelToUmaEnumValue(current_pressure_level);
+  unreported_cumulative_time_[index] += now - last_update_time_;
+
+  // Update last pressure related state.
+  last_pressure_level_ = current_pressure_level;
+  last_update_time_ = now;
+
+  // Make reports about the amount of time spent cumulatively at each level.
+  for (size_t i = 0; i < arraysize(unreported_cumulative_time_); ++i) {
+    // Report the largest number of whole seconds possible at this moment and
+    // carry around the rest for a future report.
+    if (unreported_cumulative_time_[i].is_zero())
+      continue;
+    int64_t seconds = unreported_cumulative_time_[i].InSeconds();
+    if (seconds == 0)
+      continue;
+    unreported_cumulative_time_[i] -= base::TimeDelta::FromSeconds(seconds);
+
+    ReportCumulativeTime(MemoryPressureLevelFromUmaEnumValue(
+                             static_cast<MemoryPressureLevelUMA>(i)),
+                         static_cast<int>(seconds));
+  }
+}
+
+// static
+void MemoryPressureStatsCollector::ReportCumulativeTime(
+    MemoryPressureLevel pressure_level,
+    int seconds) {
+  // Use the more primitive STATIC_HISTOGRAM_POINTER_BLOCK macro because the
+  // simple UMA_HISTOGRAM macros don't expose 'AddCount' functionality.
+  STATIC_HISTOGRAM_POINTER_BLOCK(
+      "Memory.PressureLevel",
+      AddCount(MemoryPressureLevelToUmaEnumValue(pressure_level), seconds),
+      base::LinearHistogram::FactoryGet(
+          "Memory.PressureLevel", 1, UMA_MEMORY_PRESSURE_LEVEL_COUNT,
+          UMA_MEMORY_PRESSURE_LEVEL_COUNT + 1,
+          base::HistogramBase::kUmaTargetedHistogramFlag));
+}
+
+// static
+void MemoryPressureStatsCollector::ReportLevelChange(
+    MemoryPressureLevel old_pressure_level,
+    MemoryPressureLevel new_pressure_level) {
+  UMA_HISTOGRAM_ENUMERATION("Memory.PressureLevelChange",
+                            MemoryPressureLevelChangeToUmaEnumValue(
+                                old_pressure_level, new_pressure_level),
+                            UMA_MEMORY_PRESSURE_LEVEL_CHANGE_COUNT);
+}
+
+}  // namespace memory_pressure