| OLD | NEW |
| (Empty) |
| 1 // Copyright 2015 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_MEMORY_MEMORY_PRESSURE_MONITOR_WIN_H_ | |
| 6 #define BASE_MEMORY_MEMORY_PRESSURE_MONITOR_WIN_H_ | |
| 7 | |
| 8 #include "base/base_export.h" | |
| 9 #include "base/memory/memory_pressure_listener.h" | |
| 10 #include "base/memory/memory_pressure_monitor.h" | |
| 11 #include "base/memory/weak_ptr.h" | |
| 12 #include "base/threading/thread_checker.h" | |
| 13 #include "base/timer/timer.h" | |
| 14 | |
| 15 // To not pull in windows.h. | |
| 16 typedef struct _MEMORYSTATUSEX MEMORYSTATUSEX; | |
| 17 | |
| 18 namespace base { | |
| 19 namespace win { | |
| 20 | |
| 21 // Windows memory pressure monitor. Because there is no OS provided signal this | |
| 22 // polls at a low frequency (once per second), and applies internal hysteresis. | |
| 23 class BASE_EXPORT MemoryPressureMonitor : public base::MemoryPressureMonitor { | |
| 24 public: | |
| 25 // Constants governing the polling and hysteresis behaviour of the observer. | |
| 26 | |
| 27 // The polling interval, in milliseconds. While under critical pressure, this | |
| 28 // is also the timer to repeat cleanup attempts. | |
| 29 static const int kPollingIntervalMs; | |
| 30 // The time which should pass between 2 successive moderate memory pressure | |
| 31 // signals, in milliseconds. | |
| 32 static const int kModeratePressureCooldownMs; | |
| 33 // The number of cycles that should pass between 2 successive moderate memory | |
| 34 // pressure signals. | |
| 35 static const int kModeratePressureCooldownCycles; | |
| 36 | |
| 37 // Constants governing the memory pressure level detection. | |
| 38 | |
| 39 // The amount of total system memory beyond which a system is considered to be | |
| 40 // a large-memory system. | |
| 41 static const int kLargeMemoryThresholdMb; | |
| 42 // Default minimum free memory thresholds for small-memory systems, in MB. | |
| 43 static const int kSmallMemoryDefaultModerateThresholdMb; | |
| 44 static const int kSmallMemoryDefaultCriticalThresholdMb; | |
| 45 // Default minimum free memory thresholds for large-memory systems, in MB. | |
| 46 static const int kLargeMemoryDefaultModerateThresholdMb; | |
| 47 static const int kLargeMemoryDefaultCriticalThresholdMb; | |
| 48 | |
| 49 // Default constructor. Will choose thresholds automatically basd on the | |
| 50 // actual amount of system memory. | |
| 51 MemoryPressureMonitor(); | |
| 52 | |
| 53 // Constructor with explicit memory thresholds. These represent the amount of | |
| 54 // free memory below which the applicable memory pressure state engages. | |
| 55 MemoryPressureMonitor(int moderate_threshold_mb, int critical_threshold_mb); | |
| 56 | |
| 57 ~MemoryPressureMonitor() override; | |
| 58 | |
| 59 // Schedules a memory pressure check to run soon. This must be called on the | |
| 60 // same thread where the monitor was instantiated. | |
| 61 void CheckMemoryPressureSoon(); | |
| 62 | |
| 63 // Get the current memory pressure level. This can be called from any thread. | |
| 64 MemoryPressureLevel GetCurrentPressureLevel() const override; | |
| 65 | |
| 66 // Returns the moderate pressure level free memory threshold, in MB. | |
| 67 int moderate_threshold_mb() const { return moderate_threshold_mb_; } | |
| 68 | |
| 69 // Returns the critical pressure level free memory threshold, in MB. | |
| 70 int critical_threshold_mb() const { return critical_threshold_mb_; } | |
| 71 | |
| 72 protected: | |
| 73 // Internals are exposed for unittests. | |
| 74 | |
| 75 // Automatically infers threshold values based on system memory. This invokes | |
| 76 // GetMemoryStatus so it can be mocked in unittests. | |
| 77 void InferThresholds(); | |
| 78 | |
| 79 // Starts observing the memory fill level. Calls to StartObserving should | |
| 80 // always be matched with calls to StopObserving. | |
| 81 void StartObserving(); | |
| 82 | |
| 83 // Stop observing the memory fill level. May be safely called if | |
| 84 // StartObserving has not been called. Must be called from the same thread on | |
| 85 // which the monitor was instantiated. | |
| 86 void StopObserving(); | |
| 87 | |
| 88 // Checks memory pressure, storing the current level, applying any hysteresis | |
| 89 // and emitting memory pressure level change signals as necessary. This | |
| 90 // function is called periodically while the monitor is observing memory | |
| 91 // pressure. This is split out from CheckMemoryPressureAndRecordStatistics so | |
| 92 // that it may be called by CheckMemoryPressureSoon and not invoke UMA | |
| 93 // logging. Must be called from the same thread on which the monitor was | |
| 94 // instantiated. | |
| 95 void CheckMemoryPressure(); | |
| 96 | |
| 97 // Wrapper to CheckMemoryPressure that also records the observed memory | |
| 98 // pressure level via an UMA enumeration. This is the function that is called | |
| 99 // periodically by the timer. Must be called from the same thread on which the | |
| 100 // monitor was instantiated. | |
| 101 void CheckMemoryPressureAndRecordStatistics(); | |
| 102 | |
| 103 // Calculates the current instantaneous memory pressure level. This does not | |
| 104 // use any hysteresis and simply returns the result at the current moment. Can | |
| 105 // be called on any thread. | |
| 106 MemoryPressureLevel CalculateCurrentPressureLevel(); | |
| 107 | |
| 108 // Gets system memory status. This is virtual as a unittesting hook. Returns | |
| 109 // true if the system call succeeds, false otherwise. Can be called on any | |
| 110 // thread. | |
| 111 virtual bool GetSystemMemoryStatus(MEMORYSTATUSEX* mem_status); | |
| 112 | |
| 113 private: | |
| 114 // Threshold amounts of available memory that trigger pressure levels. See | |
| 115 // memory_pressure_monitor.cc for a discussion of reasonable values for these. | |
| 116 int moderate_threshold_mb_; | |
| 117 int critical_threshold_mb_; | |
| 118 | |
| 119 // A periodic timer to check for memory pressure changes. | |
| 120 base::RepeatingTimer<MemoryPressureMonitor> timer_; | |
| 121 | |
| 122 // The current memory pressure. | |
| 123 MemoryPressureLevel current_memory_pressure_level_; | |
| 124 | |
| 125 // To slow down the amount of moderate pressure event calls, this gets used to | |
| 126 // count the number of events since the last event occured. This is used by | |
| 127 // |CheckMemoryPressure| to apply hysteresis on the raw results of | |
| 128 // |CalculateCurrentPressureLevel|. | |
| 129 int moderate_pressure_repeat_count_; | |
| 130 | |
| 131 // Ensures that this object is used from a single thread. | |
| 132 base::ThreadChecker thread_checker_; | |
| 133 | |
| 134 // Weak pointer factory to ourself used for scheduling calls to | |
| 135 // CheckMemoryPressure/CheckMemoryPressureAndRecordStatistics via |timer_|. | |
| 136 base::WeakPtrFactory<MemoryPressureMonitor> weak_ptr_factory_; | |
| 137 | |
| 138 DISALLOW_COPY_AND_ASSIGN(MemoryPressureMonitor); | |
| 139 }; | |
| 140 | |
| 141 } // namespace win | |
| 142 } // namespace base | |
| 143 | |
| 144 #endif // BASE_MEMORY_MEMORY_PRESSURE_MONITOR_WIN_H_ | |
| OLD | NEW |