base/chromeos/memory_pressure_observer_chromeos.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef BASE_CHROMEOS_MEMORY_PRESSURE_OBSERVER_CHROMEOS_H_
   6 #define BASE_CHROMEOS_MEMORY_PRESSURE_OBSERVER_CHROMEOS_H_
   7
   8 #include "base/base_export.h"
   9 #include "base/gtest_prod_util.h"
  10 #include "base/macros.h"
  11 #include "base/memory/memory_pressure_listener.h"
  12 #include "base/memory/weak_ptr.h"
  13 #include "base/timer/timer.h"
  14
  15 namespace base {
  16
  17 class TestMemoryPressureObserver;
  18
  19 ////////////////////////////////////////////////////////////////////////////////
  20 // MemoryPressureObserverChromeOS
  21 //
  22 // A class to handle the observation of our free memory. It notifies the
  23 // MemoryPressureListener of memory fill level changes, so that it can take
  24 // action to reduce memory resources accordingly.
  25 //
  26 class BASE_EXPORT MemoryPressureObserverChromeOS {
  27  public:
  28   using GetUsedMemoryInPercentCallback = int (*)();
  29
  30   // There are two memory pressure events:
  31   // MODERATE - which will mainly release caches.
  32   // CRITICAL - which will discard tabs.
  33   // The |MemoryPressureThresholds| enum selects the strategy of firing these
  34   // events: A conservative strategy will keep as much content in memory as
  35   // possible (causing the system to swap to zram) and an aggressive strategy
  36   // will release memory earlier to avoid swapping.
  37   enum MemoryPressureThresholds {
  38     // Use the system default.
  39     THRESHOLD_DEFAULT = 0,
  40     // Try to keep as much content in memory as possible.
  41     THRESHOLD_CONSERVATIVE = 1,
  42     // Discard caches earlier, allowing to keep more tabs in memory.
  43     THRESHOLD_AGGRESSIVE_CACHE_DISCARD = 2,
  44     // Discard tabs earlier, allowing the system to get faster.
  45     THRESHOLD_AGGRESSIVE_TAB_DISCARD = 3,
  46     // Discard caches and tabs earlier to allow the system to be faster.
  47     THRESHOLD_AGGRESSIVE = 4
  48   };
  49
  50   explicit MemoryPressureObserverChromeOS(MemoryPressureThresholds thresholds);
  51   virtual ~MemoryPressureObserverChromeOS();
  52
  53   // Redo the memory pressure calculation soon and call again if a critical
  54   // memory pressure prevails. Note that this call will trigger an asynchronous
  55   // action which gives the system time to release memory back into the pool.
  56   void ScheduleEarlyCheck();
  57
  58   // Get the current memory pressure level.
  59   base::MemoryPressureListener::MemoryPressureLevel GetCurrentPressureLevel() {
  60     return current_memory_pressure_level_;
  61   }
  62
  63  private:
  64   friend TestMemoryPressureObserver;
  65   // Starts observing the memory fill level.
  66   // Calls to StartObserving should always be matched with calls to
  67   // StopObserving.
  68   void StartObserving();
  69
  70   // Stop observing the memory fill level.
  71   // May be safely called if StartObserving has not been called.
  72   void StopObserving();
  73
  74   // The function which gets periodically called to check any changes in the
  75   // memory pressure. It will report pressure changes as well as continuous
  76   // critical pressure levels.
  77   void CheckMemoryPressure();
  78
  79   // The function periodically checks the memory pressure changes and records
  80   // the UMA histogram statistics for the current memory pressure level.
  81   void CheckMemoryPressureAndRecordStatistics();
  82
  83   // Get the memory pressure in percent (virtual for testing).
  84   virtual int GetUsedMemoryInPercent();
  85
  86   // The current memory pressure.
  87   base::MemoryPressureListener::MemoryPressureLevel
  88       current_memory_pressure_level_;
  89
  90   // A periodic timer to check for resource pressure changes. This will get
  91   // replaced by a kernel triggered event system (see crbug.com/381196).
  92   base::RepeatingTimer<MemoryPressureObserverChromeOS> timer_;
  93
  94   // To slow down the amount of moderate pressure event calls, this counter
  95   // gets used to count the number of events since the last event occured.
  96   int moderate_pressure_repeat_count_;
  97
  98   // The thresholds for moderate and critical pressure.
  99   const int moderate_pressure_threshold_percent_;
 100   const int critical_pressure_threshold_percent_;
 101
 102   base::WeakPtrFactory<MemoryPressureObserverChromeOS> weak_ptr_factory_;
 103
 104   DISALLOW_COPY_AND_ASSIGN(MemoryPressureObserverChromeOS);
 105 };
 106
 107 }  // namespace base
 108
 109 #endif  // BASE_CHROMEOS_MEMORY_PRESSURE_OBSERVER_CHROMEOS_H_