| OLD | NEW |
|---|
| (Empty) |
| 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 #include "base/chromeos/memory_pressure_monitor.h" | |
| 6 | |
| 7 #include <fcntl.h> | |
| 8 #include <sys/select.h> | |
| 9 | |
| 10 #include "base/metrics/histogram_macros.h" | |
| 11 #include "base/posix/eintr_wrapper.h" | |
| 12 #include "base/process/process_metrics.h" | |
| 13 #include "base/single_thread_task_runner.h" | |
| 14 #include "base/thread_task_runner_handle.h" | |
| 15 #include "base/time/time.h" | |
| 16 | |
| 17 namespace base { | |
| 18 namespace chromeos { | |
| 19 | |
| 20 namespace { | |
| 21 | |
| 22 // The time between memory pressure checks. While under critical pressure, this | |
| 23 // is also the timer to repeat cleanup attempts. | |
| 24 const int kMemoryPressureIntervalMs = 1000; | |
| 25 | |
| 26 // The time which should pass between two moderate memory pressure calls. | |
| 27 const int kModerateMemoryPressureCooldownMs = 10000; | |
| 28 | |
| 29 // Number of event polls before the next moderate pressure event can be sent. | |
| 30 const int kModerateMemoryPressureCooldown = | |
| 31 kModerateMemoryPressureCooldownMs / kMemoryPressureIntervalMs; | |
| 32 | |
| 33 // Threshold constants to emit pressure events. | |
| 34 const int kNormalMemoryPressureModerateThresholdPercent = 60; | |
| 35 const int kNormalMemoryPressureCriticalThresholdPercent = 95; | |
| 36 const int kAggressiveMemoryPressureModerateThresholdPercent = 35; | |
| 37 const int kAggressiveMemoryPressureCriticalThresholdPercent = 70; | |
| 38 | |
| 39 // The possible state for memory pressure level. The values should be in line | |
| 40 // with values in MemoryPressureListener::MemoryPressureLevel and should be | |
| 41 // updated if more memory pressure levels are introduced. | |
| 42 enum MemoryPressureLevelUMA { | |
| 43 MEMORY_PRESSURE_LEVEL_NONE = 0, | |
| 44 MEMORY_PRESSURE_LEVEL_MODERATE, | |
| 45 MEMORY_PRESSURE_LEVEL_CRITICAL, | |
| 46 NUM_MEMORY_PRESSURE_LEVELS | |
| 47 }; | |
| 48 | |
| 49 // This is the file that will exist if low memory notification is available | |
| 50 // on the device. Whenever it becomes readable, it signals a low memory | |
| 51 // condition. | |
| 52 const char kLowMemFile[] = "/dev/chromeos-low-mem"; | |
| 53 | |
| 54 // Converts a |MemoryPressureThreshold| value into a used memory percentage for | |
| 55 // the moderate pressure event. | |
| 56 int GetModerateMemoryThresholdInPercent( | |
| 57 MemoryPressureMonitor::MemoryPressureThresholds thresholds) { | |
| 58 return thresholds == MemoryPressureMonitor:: | |
| 59 THRESHOLD_AGGRESSIVE_CACHE_DISCARD || | |
| 60 thresholds == MemoryPressureMonitor::THRESHOLD_AGGRESSIVE | |
| 61 ? kAggressiveMemoryPressureModerateThresholdPercent | |
| 62 : kNormalMemoryPressureModerateThresholdPercent; | |
| 63 } | |
| 64 | |
| 65 // Converts a |MemoryPressureThreshold| value into a used memory percentage for | |
| 66 // the critical pressure event. | |
| 67 int GetCriticalMemoryThresholdInPercent( | |
| 68 MemoryPressureMonitor::MemoryPressureThresholds thresholds) { | |
| 69 return thresholds == MemoryPressureMonitor:: | |
| 70 THRESHOLD_AGGRESSIVE_TAB_DISCARD || | |
| 71 thresholds == MemoryPressureMonitor::THRESHOLD_AGGRESSIVE | |
| 72 ? kAggressiveMemoryPressureCriticalThresholdPercent | |
| 73 : kNormalMemoryPressureCriticalThresholdPercent; | |
| 74 } | |
| 75 | |
| 76 // Converts free percent of memory into a memory pressure value. | |
| 77 MemoryPressureListener::MemoryPressureLevel GetMemoryPressureLevelFromFillLevel( | |
| 78 int actual_fill_level, | |
| 79 int moderate_threshold, | |
| 80 int critical_threshold) { | |
| 81 if (actual_fill_level < moderate_threshold) | |
| 82 return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE; | |
| 83 return actual_fill_level < critical_threshold | |
| 84 ? MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE | |
| 85 : MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL; | |
| 86 } | |
| 87 | |
| 88 // This function will be called less then once a second. It will check if | |
| 89 // the kernel has detected a low memory situation. | |
| 90 bool IsLowMemoryCondition(int file_descriptor) { | |
| 91 fd_set fds; | |
| 92 struct timeval tv; | |
| 93 | |
| 94 FD_ZERO(&fds); | |
| 95 FD_SET(file_descriptor, &fds); | |
| 96 | |
| 97 tv.tv_sec = 0; | |
| 98 tv.tv_usec = 0; | |
| 99 | |
| 100 return HANDLE_EINTR(select(file_descriptor + 1, &fds, NULL, NULL, &tv)) > 0; | |
| 101 } | |
| 102 | |
| 103 } // namespace | |
| 104 | |
| 105 MemoryPressureMonitor::MemoryPressureMonitor( | |
| 106 MemoryPressureThresholds thresholds) | |
| 107 : current_memory_pressure_level_( | |
| 108 MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE), | |
| 109 moderate_pressure_repeat_count_(0), | |
| 110 moderate_pressure_threshold_percent_( | |
| 111 GetModerateMemoryThresholdInPercent(thresholds)), | |
| 112 critical_pressure_threshold_percent_( | |
| 113 GetCriticalMemoryThresholdInPercent(thresholds)), | |
| 114 low_mem_file_(HANDLE_EINTR(::open(kLowMemFile, O_RDONLY))), | |
| 115 weak_ptr_factory_(this) { | |
| 116 StartObserving(); | |
| 117 LOG_IF(ERROR, !low_mem_file_.is_valid()) << "Cannot open kernel listener"; | |
| 118 } | |
| 119 | |
| 120 MemoryPressureMonitor::~MemoryPressureMonitor() { | |
| 121 StopObserving(); | |
| 122 } | |
| 123 | |
| 124 void MemoryPressureMonitor::ScheduleEarlyCheck() { | |
| 125 ThreadTaskRunnerHandle::Get()->PostTask( | |
| 126 FROM_HERE, Bind(&MemoryPressureMonitor::CheckMemoryPressure, | |
| 127 weak_ptr_factory_.GetWeakPtr())); | |
| 128 } | |
| 129 | |
| 130 MemoryPressureListener::MemoryPressureLevel | |
| 131 MemoryPressureMonitor::GetCurrentPressureLevel() const { | |
| 132 return current_memory_pressure_level_; | |
| 133 } | |
| 134 | |
| 135 // static | |
| 136 MemoryPressureMonitor* MemoryPressureMonitor::Get() { | |
| 137 return static_cast<MemoryPressureMonitor*>( | |
| 138 base::MemoryPressureMonitor::Get()); | |
| 139 } | |
| 140 | |
| 141 void MemoryPressureMonitor::StartObserving() { | |
| 142 timer_.Start(FROM_HERE, | |
| 143 TimeDelta::FromMilliseconds(kMemoryPressureIntervalMs), | |
| 144 Bind(&MemoryPressureMonitor:: | |
| 145 CheckMemoryPressureAndRecordStatistics, | |
| 146 weak_ptr_factory_.GetWeakPtr())); | |
| 147 } | |
| 148 | |
| 149 void MemoryPressureMonitor::StopObserving() { | |
| 150 // If StartObserving failed, StopObserving will still get called. | |
| 151 timer_.Stop(); | |
| 152 } | |
| 153 | |
| 154 void MemoryPressureMonitor::CheckMemoryPressureAndRecordStatistics() { | |
| 155 CheckMemoryPressure(); | |
| 156 | |
| 157 // Record UMA histogram statistics for the current memory pressure level. | |
| 158 MemoryPressureLevelUMA memory_pressure_level_uma(MEMORY_PRESSURE_LEVEL_NONE); | |
| 159 switch (current_memory_pressure_level_) { | |
| 160 case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE: | |
| 161 memory_pressure_level_uma = MEMORY_PRESSURE_LEVEL_NONE; | |
| 162 break; | |
| 163 case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE: | |
| 164 memory_pressure_level_uma = MEMORY_PRESSURE_LEVEL_MODERATE; | |
| 165 break; | |
| 166 case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL: | |
| 167 memory_pressure_level_uma = MEMORY_PRESSURE_LEVEL_CRITICAL; | |
| 168 break; | |
| 169 } | |
| 170 | |
| 171 UMA_HISTOGRAM_ENUMERATION("ChromeOS.MemoryPressureLevel", | |
| 172 memory_pressure_level_uma, | |
| 173 NUM_MEMORY_PRESSURE_LEVELS); | |
| 174 } | |
| 175 | |
| 176 void MemoryPressureMonitor::CheckMemoryPressure() { | |
| 177 MemoryPressureListener::MemoryPressureLevel old_pressure = | |
| 178 current_memory_pressure_level_; | |
| 179 | |
| 180 // If we have the kernel low memory observer, we use it's flag instead of our | |
| 181 // own computation (for now). Note that in "simulation mode" it can be null. | |
| 182 // TODO(skuhne): We need to add code which makes sure that the kernel and this | |
| 183 // computation come to similar results and then remove this override again. | |
| 184 // TODO(skuhne): Add some testing framework here to see how close the kernel | |
| 185 // and the internal functions are. | |
| 186 if (low_mem_file_.is_valid() && IsLowMemoryCondition(low_mem_file_.get())) { | |
| 187 current_memory_pressure_level_ = | |
| 188 MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL; | |
| 189 } else { | |
| 190 current_memory_pressure_level_ = GetMemoryPressureLevelFromFillLevel( | |
| 191 GetUsedMemoryInPercent(), | |
| 192 moderate_pressure_threshold_percent_, | |
| 193 critical_pressure_threshold_percent_); | |
| 194 | |
| 195 // When listening to the kernel, we ignore the reported memory pressure | |
| 196 // level from our own computation and reduce critical to moderate. | |
| 197 if (low_mem_file_.is_valid() && | |
| 198 current_memory_pressure_level_ == | |
| 199 MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) { | |
| 200 current_memory_pressure_level_ = | |
| 201 MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE; | |
| 202 } | |
| 203 } | |
| 204 | |
| 205 // In case there is no memory pressure we do not notify. | |
| 206 if (current_memory_pressure_level_ == | |
| 207 MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE) { | |
| 208 return; | |
| 209 } | |
| 210 if (old_pressure == current_memory_pressure_level_) { | |
| 211 // If the memory pressure is still at the same level, we notify again for a | |
| 212 // critical level. In case of a moderate level repeat however, we only send | |
| 213 // a notification after a certain time has passed. | |
| 214 if (current_memory_pressure_level_ == | |
| 215 MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE && | |
| 216 ++moderate_pressure_repeat_count_ < | |
| 217 kModerateMemoryPressureCooldown) { | |
| 218 return; | |
| 219 } | |
| 220 } else if (current_memory_pressure_level_ == | |
| 221 MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE && | |
| 222 old_pressure == | |
| 223 MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL) { | |
| 224 // When we reducing the pressure level from critical to moderate, we | |
| 225 // restart the timeout and do not send another notification. | |
| 226 moderate_pressure_repeat_count_ = 0; | |
| 227 return; | |
| 228 } | |
| 229 moderate_pressure_repeat_count_ = 0; | |
| 230 MemoryPressureListener::NotifyMemoryPressure(current_memory_pressure_level_); | |
| 231 } | |
| 232 | |
| 233 // Gets the used ChromeOS memory in percent. | |
| 234 int MemoryPressureMonitor::GetUsedMemoryInPercent() { | |
| 235 base::SystemMemoryInfoKB info; | |
| 236 if (!base::GetSystemMemoryInfo(&info)) { | |
| 237 VLOG(1) << "Cannot determine the free memory of the system."; | |
| 238 return 0; | |
| 239 } | |
| 240 // TODO(skuhne): Instead of adding the kernel memory pressure calculation | |
| 241 // logic here, we should have a kernel mechanism similar to the low memory | |
| 242 // notifier in ChromeOS which offers multiple pressure states. | |
| 243 // To track this, we have crbug.com/381196. | |
| 244 | |
| 245 // The available memory consists of "real" and virtual (z)ram memory. | |
| 246 // Since swappable memory uses a non pre-deterministic compression and | |
| 247 // the compression creates its own "dynamic" in the system, it gets | |
| 248 // de-emphasized by the |kSwapWeight| factor. | |
| 249 const int kSwapWeight = 4; | |
| 250 | |
| 251 // The total memory we have is the "real memory" plus the virtual (z)ram. | |
| 252 int total_memory = info.total + info.swap_total / kSwapWeight; | |
| 253 | |
| 254 // The kernel internally uses 50MB. | |
| 255 const int kMinFileMemory = 50 * 1024; | |
| 256 | |
| 257 // Most file memory can be easily reclaimed. | |
| 258 int file_memory = info.active_file + info.inactive_file; | |
| 259 // unless it is dirty or it's a minimal portion which is required. | |
| 260 file_memory -= info.dirty + kMinFileMemory; | |
| 261 | |
| 262 // Available memory is the sum of free, swap and easy reclaimable memory. | |
| 263 int available_memory = | |
| 264 info.free + info.swap_free / kSwapWeight + file_memory; | |
| 265 | |
| 266 DCHECK(available_memory < total_memory); | |
| 267 int percentage = ((total_memory - available_memory) * 100) / total_memory; | |
| 268 return percentage; | |
| 269 } | |
| 270 | |
| 271 } // namespace chromeos | |
| 272 } // namespace base | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1149223002:
Avoid basename conflict from memory_pressure_monitor.cc (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master