WIP: memory coordinator: Check /dev/chromeos-low-mem to determine memory condition

base/memory/memory_pressure_monitor_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/memory/memory_pressure_monitor_chromeos.h"
 
-#include <fcntl.h>
-#include <sys/select.h>
-
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
-#include "base/posix/eintr_wrapper.h"
 #include "base/process/process_metrics.h"
 #include "base/single_thread_task_runner.h"
-#include "base/sys_info.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 
 namespace base {
 namespace chromeos {
 
 namespace {
 
 // The time between memory pressure checks. While under critical pressure, this
 // is also the timer to repeat cleanup attempts.
@@ skipping 15 matching lines @@
 // The possible state for memory pressure level. The values should be in line
 // with values in MemoryPressureListener::MemoryPressureLevel and should be
 // updated if more memory pressure levels are introduced.
 enum MemoryPressureLevelUMA {
   MEMORY_PRESSURE_LEVEL_NONE = 0,
   MEMORY_PRESSURE_LEVEL_MODERATE,
   MEMORY_PRESSURE_LEVEL_CRITICAL,
   NUM_MEMORY_PRESSURE_LEVELS
 };
 
-// This is the file that will exist if low memory notification is available
-// on the device.  Whenever it becomes readable, it signals a low memory
-// condition.
-const char kLowMemFile[] = "/dev/chromeos-low-mem";
-
 // Converts a |MemoryPressureThreshold| value into a used memory percentage for
 // the moderate pressure event.
 int GetModerateMemoryThresholdInPercent(
     MemoryPressureMonitor::MemoryPressureThresholds thresholds) {
   return thresholds == MemoryPressureMonitor::
                            THRESHOLD_AGGRESSIVE_CACHE_DISCARD ||
          thresholds == MemoryPressureMonitor::THRESHOLD_AGGRESSIVE
              ? kAggressiveMemoryPressureModerateThresholdPercent
              : kNormalMemoryPressureModerateThresholdPercent;
 }
@@ skipping 14 matching lines @@
     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;
 }
 
-// This function will be called less than once a second. It will check if
-// the kernel has detected a low memory situation.
-bool IsLowMemoryCondition(int file_descriptor) {
-  fd_set fds;
-  struct timeval tv;
-
-  FD_ZERO(&fds);
-  FD_SET(file_descriptor, &fds);
-
-  tv.tv_sec = 0;
-  tv.tv_usec = 0;
-
-  return HANDLE_EINTR(select(file_descriptor + 1, &fds, NULL, NULL, &tv)) > 0;
-}
-
 }  // namespace
 
 MemoryPressureMonitor::MemoryPressureMonitor(
     MemoryPressureThresholds thresholds)
     : current_memory_pressure_level_(
           MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE),
       moderate_pressure_repeat_count_(0),
       seconds_since_reporting_(0),
       moderate_pressure_threshold_percent_(
           GetModerateMemoryThresholdInPercent(thresholds)),
       critical_pressure_threshold_percent_(
           GetCriticalMemoryThresholdInPercent(thresholds)),
-      low_mem_file_(HANDLE_EINTR(::open(kLowMemFile, O_RDONLY))),
+      low_mem_observer_(base::MakeUnique<LowMemoryObserver>()),
       dispatch_callback_(
           base::Bind(&MemoryPressureListener::NotifyMemoryPressure)),
       weak_ptr_factory_(this) {
   StartObserving();
-  LOG_IF(ERROR,
-         base::SysInfo::IsRunningOnChromeOS() && !low_mem_file_.is_valid())
-      << "Cannot open kernel listener";
 }
 
 MemoryPressureMonitor::~MemoryPressureMonitor() {
   StopObserving();
 }
 
 void MemoryPressureMonitor::ScheduleEarlyCheck() {
   ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, Bind(&MemoryPressureMonitor::CheckMemoryPressure,
                       weak_ptr_factory_.GetWeakPtr()));
@@ skipping 53 matching lines @@
 void MemoryPressureMonitor::CheckMemoryPressure() {
   MemoryPressureListener::MemoryPressureLevel old_pressure =
       current_memory_pressure_level_;
 
   // If we have the kernel low memory observer, we use it's flag instead of our
   // own computation (for now). Note that in "simulation mode" it can be null.
   // TODO(skuhne): We need to add code which makes sure that the kernel and this
   // computation come to similar results and then remove this override again.
   // TODO(skuhne): Add some testing framework here to see how close the kernel
   // and the internal functions are.
-  if (low_mem_file_.is_valid() && IsLowMemoryCondition(low_mem_file_.get())) {
+  if (low_mem_observer_->IsLowMemoryCondition()) {
     current_memory_pressure_level_ =
         MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
   } else {
     current_memory_pressure_level_ = GetMemoryPressureLevelFromFillLevel(
         GetUsedMemoryInPercent(),
         moderate_pressure_threshold_percent_,
         critical_pressure_threshold_percent_);
 
     // When listening to the kernel, we ignore the reported memory pressure
     // level from our own computation and reduce critical to moderate.
-    if (low_mem_file_.is_valid() &&
+    if (low_mem_observer_->is_valid() &&
         current_memory_pressure_level_ ==
-        MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
+            MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) {
       current_memory_pressure_level_ =
           MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE;
     }
   }
 
   // In case there is no memory pressure we do not notify.
   if (current_memory_pressure_level_ ==
       MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE) {
     return;
   }
@@ skipping 58 matching lines @@
   return percentage;
 }
 
 void MemoryPressureMonitor::SetDispatchCallback(
     const DispatchCallback& callback) {
   dispatch_callback_ = callback;
 }
 
 }  // namespace chromeos
 }  // namespace base