[Chromecast] Use MemAvailable to compute memory pressure

chromecast/browser/cast_memory_pressure_monitor.cc

 // Copyright 2016 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 "chromecast/browser/cast_memory_pressure_monitor.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/process/process_metrics.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chromecast/base/chromecast_switches.h"
 #include "chromecast/base/metrics/cast_metrics_helper.h"
 
 namespace chromecast {
 namespace {
 
 // Memory thresholds (as fraction of total memory) for memory pressure levels.
 // See more detailed description of pressure heuristic in PollPressureLevel.
 // TODO(halliwell): tune thresholds based on data.
-constexpr float kCriticalMemoryFraction = 0.2f;
-constexpr float kModerateMemoryFraction = 0.3f;
+constexpr float kCriticalMemoryFraction = 0.25f;
+constexpr float kModerateMemoryFraction = 0.4f;
 
 // Memory thresholds in MB for the simple heuristic based on 'free' memory.
 constexpr int kCriticalFreeMemoryKB = 20 * 1024;
 constexpr int kModerateFreeMemoryKB = 30 * 1024;
 
 constexpr int kPollingIntervalMS = 5000;
 
 int GetSystemReservedKb() {
   int rtn_kb_ = 0;
   const base::CommandLine* command_line(base::CommandLine::ForCurrentProcess());
@@ skipping 23 matching lines @@
 }
 
 void CastMemoryPressureMonitor::PollPressureLevel() {
   MemoryPressureLevel level =
       base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
 
   base::SystemMemoryInfoKB info;
   if (!base::GetSystemMemoryInfo(&info)) {
     LOG(ERROR) << "GetSystemMemoryInfo failed";
   } else {
-    if (system_reserved_kb_ == 0) {
-      // System reserved memory not configured: we have no idea how much of
-      // buffers+cached is safe to treat as usable, so use a simple heuristic
-      // based purely on 'free' memory.
+    if (system_reserved_kb_ != 0 || info.available != 0) {
+      // Preferred memory pressure heuristic:
+      // 1. Use /proc/meminfo's MemAvailable if possible, fall back to estimate
+      // of free + buffers + cached otherwise.
+      const int total_available =
+          (info.available != 0) ? info.available
+                                : (info.free + info.buffers + info.cached);
+
+      // 2. Allow some memory to be 'reserved' on command line.
+      const int available = total_available - system_reserved_kb_;
+      const int total = info.total - system_reserved_kb_;
+      DCHECK_GT(total, 0);
+      const float ratio = available / float(total);

[wzhong, 2016/07/14 23:55:25]

static_cast

[halliwell, 2016/07/15 00:10:31]

Sure, done.

+
+      if (ratio < kCriticalMemoryFraction)
+        level = base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
+      else if (ratio < kModerateMemoryFraction)
+        level = base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE;
+    } else {
+      // Backup method purely using 'free' memory.  It may generate more
+      // pressure events than necessary, since more memory may actually be free.
       if (info.free < kCriticalFreeMemoryKB)
         level = base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
       else if (info.free < kModerateFreeMemoryKB)
         level = base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE;
-    } else {
-      // Platform has configured the 'reserved' memory; treat buffers plus
-      // cached minus reserved as available.
-      const float max_free =
-          info.free + info.buffers + info.cached - system_reserved_kb_;
-      const float total = info.total - system_reserved_kb_;
-      DCHECK(total > 0);
-
-      if ((max_free / total) < kCriticalMemoryFraction)
-        level = base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
-      else if ((max_free / total) < kModerateMemoryFraction)
-        level = base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE;
     }
   }
 
   UpdateMemoryPressureLevel(level);
 
   UMA_HISTOGRAM_PERCENTAGE("Platform.MeminfoMemFree",
                            (info.free * 100.0) / info.total);
   UMA_HISTOGRAM_CUSTOM_COUNTS("Platform.Cast.MeminfoMemFreeDerived",
                               (info.free + info.buffers + info.cached) / 1024,
                               1, 500, 100);
@@ skipping 22 matching lines @@
   metrics::CastMetricsHelper::GetInstance()->RecordApplicationEventWithValue(
       "Memory.Pressure.LevelChange", new_level);
 }
 
 void CastMemoryPressureMonitor::SetDispatchCallback(
     const DispatchCallback& callback) {
   dispatch_callback_ = callback;
 }
 
 }  // namespace chromecast