Create base::win::MemoryPressureMonitor class.

base/win/memory_pressure_monitor.cc

+// Copyright 2015 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/win/memory_pressure_monitor.h"
+
+#include <windows.h>
+
+#include "base/metrics/histogram_macros.h"
+#include "base/single_thread_task_runner.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/time/time.h"
+
+namespace base {
+namespace win {
+
+namespace {
+
+// TODO(chrisha): Explore the following constants further with an experiment.
+
+// Moderate and critical memory load percentages. These percentages are applied
+// to both system memory and virtual memory.
+const int kModerateThresholdPercent = 60;

[brucedawson, 2015/05/06 18:44:37]

I'm not sure that the threshold percentages make sense for physical memory. On
large memory systems they will cause memory trimming to happen when lots of
memory (25.6 GB in my case!) is still available. The 95% threshold might make
sense, but I'm not at all sure that the 60% one ever does.

+const int kCriticalThresholdPercent = 95;
+
+// Absolute system memory requirements. These are modeled after typical renderer
+// sizes on Windows sytems (rounded to the neared 10 MB). These are applied to
+// system memory only. Intended as a lower bound to the above percentages on
+// low-end systems. Taken from the Memory.Renderer UMA statistic.
+const int kModerateThresholdMb = 300;  // 95th percentile renderer size.
+const int kCriticalThresholdMb = 60;   // 50th percentile renderer size.

[brucedawson, 2015/05/06 18:44:37]

I'm concerned about these values. The description suggests that they are related
to typical renderer process sizes but it's not clear why that is a relevant
number to compare against system-wide available memory. It sounds like the logic
is that the system is under moderate memory pressure if there isn't enough
available memory to create a new 95th percentile (quite big) renderer, and the
system is under critical memory pressure if there isn't enough available to
create a new 50th percentile renderer.

Unfortunately that definition does not, I believe, correspond to how Windows
actually works. If available memory drops enough then Windows will start
trimming working sets and writing data to pagefile.sys in order to bring
available memory back up. Therefore we should only ever see available memory
drop to 300 MB if the system is under such a heavy and sustained increase in
memory demands that the system cannot trim/write data fast enough. This is a
very rare situation and it is quite possible for the system to be arbitrarily
badly squeezed for memory without the either physical memory limit being
reached. And, if the 60/300 MB limits are ever reached, Windows will quickly
free/write memory to move available memory back up.

I just ran my ExhaustMemory test program on a Windows laptop with 8 GB of
physical memory. Once available memory (shown in Task Manager) got to about 800
MB then Windows started releasing some memory. After allocating a few more 100
MB blocks I was able to push memory down to about 400 MB available. After that,
every time I allocated another 100 MB of memory the available memory would drop
but then immediately rebound to somewhere between 300 and 400 MB of memory.

Once Windows starts writing to the pagefile the performance of the system is
already compromised and this should be considered significant memory pressure.
Available memory can potentially warn when Windows is getting close to writing
to the pagefile, but it cannot tell when it is-writing/has-written to the
pagefile because writing to the pagefile increases available memory!

My tests suggest that kModerateThresholdMB should be ~800-100 MB, and
kCriticalThresholdMb should be ~400 MB. The ~800-1000 MB is based on what I have
been taught about the Windows virtual memory system, and the ~400 MB number is
based on my tests today, which are regrettably limited to a single machine.

It may be that panicking at 400 MB is not appropriate, but panicking at 300 MB
or 60 MB is almost irrelevant.

+
+// Enumeration of UMA memory pressure levels. This needs to be kept in sync with
+// histograms.xml and the memory pressure levels defined in
+// MemoryPressureListener.
+enum MemoryPressureLevelUMA {
+  UMA_MEMORY_PRESSURE_LEVEL_NONE = 0,
+  UMA_MEMORY_PRESSURE_LEVEL_MODERATE = 1,
+  UMA_MEMORY_PRESSURE_LEVEL_CRITICAL = 2,
+  // This must be the last value in the enum.
+  UMA_MEMORY_PRESSURE_LEVEL_COUNT,
+};
+
+// Converts a memory pressure level to an UMA enumeration value.
+MemoryPressureLevelUMA MemoryPressureLevelToUmaEnumValue(
+    MemoryPressureListener::MemoryPressureLevel level) {
+  switch (level) {
+    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE:
+      return UMA_MEMORY_PRESSURE_LEVEL_NONE;
+    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE:
+      return UMA_MEMORY_PRESSURE_LEVEL_MODERATE;
+    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL:
+      return UMA_MEMORY_PRESSURE_LEVEL_CRITICAL;
+  }
+  NOTREACHED();
+  return UMA_MEMORY_PRESSURE_LEVEL_NONE;
+}
+
+}  // namespace
+
+// The following constants have been lifted from similar values in the ChromeOS
+// memory pressure monitor. The values were determined experimentally to ensure
+// sufficient responsiveness of the memory pressure subsystem, and minimal
+// overhead.
+const int MemoryPressureMonitor::kPollingIntervalMs = 1000;
+const int MemoryPressureMonitor::kModeratePressureCooldownMs = 10000;
+const int MemoryPressureMonitor::kModeratePressureCooldownCycles =
+    kModeratePressureCooldownMs / kPollingIntervalMs;
+
+MemoryPressureMonitor::MemoryPressureMonitor()
+    : current_memory_pressure_level_(
+          MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE),
+      moderate_pressure_repeat_count_(0),
+      weak_ptr_factory_(this) {
+  StartObserving();
+}
+
+MemoryPressureMonitor::~MemoryPressureMonitor() {
+  StopObserving();
+}
+
+void MemoryPressureMonitor::CheckMemoryPressureSoon() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, Bind(&MemoryPressureMonitor::CheckMemoryPressure,
+                      weak_ptr_factory_.GetWeakPtr()));
+}
+
+MemoryPressureListener::MemoryPressureLevel
+MemoryPressureMonitor::GetCurrentPressureLevel() const {
+  return current_memory_pressure_level_;
+}
+
+void MemoryPressureMonitor::StartObserving() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  timer_.Start(FROM_HERE,
+               TimeDelta::FromMilliseconds(kPollingIntervalMs),
+               Bind(&MemoryPressureMonitor::
+                        CheckMemoryPressureAndRecordStatistics,
+                    weak_ptr_factory_.GetWeakPtr()));
+}
+
+void MemoryPressureMonitor::StopObserving() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // If StartObserving failed, StopObserving will still get called.
+  timer_.Stop();
+  weak_ptr_factory_.InvalidateWeakPtrs();
+}
+
+void MemoryPressureMonitor::CheckMemoryPressure() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  // Get the previous pressure level and update the current one.
+  MemoryPressureLevel old_pressure = current_memory_pressure_level_;
+  current_memory_pressure_level_ = CalculateCurrentPressureLevel();
+
+  // |notify| will be set to true if MemoryPressureListeners need to be
+  // notified of a memory pressure level state change.
+  bool notify = false;
+  switch (current_memory_pressure_level_) {
+    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE:
+      break;
+
+    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE:
+      if (old_pressure != current_memory_pressure_level_) {
+        // This is a new transition to moderate pressure so notify.
+        moderate_pressure_repeat_count_ = 0;
+        notify = true;
+      } else {
+        // Already in moderate pressure, only notify if sustained over the
+        // cooldown period.
+        if (++moderate_pressure_repeat_count_ ==
+                kModeratePressureCooldownCycles) {
+          moderate_pressure_repeat_count_ = 0;
+          notify = true;
+        }
+      }
+      break;
+
+    case MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL:
+      // Always notify of critical pressure levels.
+      notify = true;
+      break;
+  }
+
+  if (!notify)
+    return;
+
+  // Emit a notification of the current memory pressure level. This can only
+  // happen for moderate and critical pressure levels.
+  DCHECK_NE(MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE,
+            current_memory_pressure_level_);
+  MemoryPressureListener::NotifyMemoryPressure(current_memory_pressure_level_);
+}
+
+void MemoryPressureMonitor::CheckMemoryPressureAndRecordStatistics() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  CheckMemoryPressure();
+
+  UMA_HISTOGRAM_ENUMERATION(
+      "Memory.PressureLevel",
+      MemoryPressureLevelToUmaEnumValue(current_memory_pressure_level_),
+      UMA_MEMORY_PRESSURE_LEVEL_COUNT);
+}
+
+MemoryPressureListener::MemoryPressureLevel
+MemoryPressureMonitor::CalculateCurrentPressureLevel() {
+  MEMORYSTATUSEX mem_status = {};
+  if (!GetSystemMemoryStatus(&mem_status))
+    return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
+
+  // How much of the system's physical memory is actively being used by
+  // pages that are in the working sets of running programs.
+  int phys_load = mem_status.dwMemoryLoad;
+
+  // How much system memory is actively available for use right now, in MBs.
+  static const DWORDLONG kMBBytes = 1024 * 1024;
+  int phys_free = static_cast<int>(mem_status.ullAvailPhys / kMBBytes);
+
+  // Determine if the physical memory is under critical memory pressure.
+  if (phys_load > kCriticalThresholdPercent ||
+      phys_free < kCriticalThresholdMb) {
+    return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
+  }
+
+  // On 64-bit platforms there is little value in calculating virtual memory
+  // pressure as it is at least 3 orders of magnitude larger than system memory.
+#if !defined(ARCH_CPU_64_BITS)
+  // The virtual load of the current process. This is the percentage of virtual
+  // memory that is reserved or committed.
+  int virt_load = 100 - static_cast<int>(
+      100 * mem_status.ullAvailVirtual / mem_status.ullTotalVirtual);
+
+  // Determine if the virtual memory is under critical memory pressure.
+  if (virt_load > kCriticalThresholdPercent)
+    return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL;
+
+  // Determine if the virtual memory is under moderate memory pressure.
+  if (virt_load > kModerateThresholdPercent)
+    return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE;
+#endif  // !defined(ARCH_CPU_64_BITS)
+
+  // Determine if the physical memory is under moderate memory pressure. This
+  // is done after the virtual memory checking to give that a chance to emit a
+  // critical pressure signal.
+  if (phys_load > kModerateThresholdPercent ||
+      phys_free < kModerateThresholdMb) {
+    return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE;
+  }
+
+  // No memory pressure was detected.
+  return MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE;
+}
+
+bool MemoryPressureMonitor::GetSystemMemoryStatus(
+    MEMORYSTATUSEX* mem_status) {
+  DCHECK(mem_status != nullptr);
+  mem_status->dwLength = sizeof(MEMORYSTATUSEX);
+  if (!::GlobalMemoryStatusEx(mem_status))
+    return false;
+  return true;
+}
+
+}  // namespace win
+}  // namespace base