memory coordinator: Purge memory under memory pressure

content/browser/memory/memory_coordinator_impl.cc

 // Copyright 2016 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 "content/browser/memory/memory_coordinator_impl.h"
 
 #include "base/memory/memory_coordinator_client_registry.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/process/process_handle.h"
@@ skipping 10 matching lines @@
 #include "content/public/common/content_features.h"
 #include "mojo/public/cpp/bindings/binding.h"
 
 namespace content {
 
 using MemoryState = base::MemoryState;
 
 namespace {
 
 const int kDefaultMinimumTransitionPeriodSeconds = 30;
+const int kDefaultBackgroundChildPurgeCandidatePeriodSeconds = 30;
 
 mojom::MemoryState ToMojomMemoryState(MemoryState state) {
   switch (state) {
     case MemoryState::UNKNOWN:
       return mojom::MemoryState::UNKNOWN;
     case MemoryState::NORMAL:
       return mojom::MemoryState::NORMAL;
     case MemoryState::THROTTLED:
       return mojom::MemoryState::THROTTLED;
     case MemoryState::SUSPENDED:
@@ skipping 29 matching lines @@
       return MemoryState::NORMAL;
     case MemoryCondition::WARNING:
       return is_visible ? MemoryState::NORMAL : MemoryState::THROTTLED;
     case MemoryCondition::CRITICAL:
       return MemoryState::THROTTLED;
   }
   NOTREACHED();
   return MemoryState::NORMAL;
 }
 
+void RecordBrowserPurge(size_t before) {
+  auto metrics = base::ProcessMetrics::CreateCurrentProcessMetrics();
+  size_t after = metrics->GetWorkingSetSize();
+  int64_t bytes = static_cast<int64_t>(before) - static_cast<int64_t>(after);
+  if (bytes < 0)
+    bytes = 0;
+  UMA_HISTOGRAM_MEMORY_LARGE_MB("Memory.Experimental.Browser.PurgedMemory",
+                                bytes / 1024 / 1024);
+}
+
 }  // namespace
 
 // The implementation of MemoryCoordinatorHandle. See memory_coordinator.mojom
 // for the role of this class.
 class MemoryCoordinatorHandleImpl : public mojom::MemoryCoordinatorHandle {
  public:
   MemoryCoordinatorHandleImpl(mojom::MemoryCoordinatorHandleRequest request,
                               MemoryCoordinatorImpl* coordinator,
                               int render_process_id);
   ~MemoryCoordinatorHandleImpl() override;
@@ skipping 188 matching lines @@
     if (render_process_host && render_process_host->GetHandle() == handle)
       return iter.second.memory_state;
   }
   return MemoryState::UNKNOWN;
 }
 
 void MemoryCoordinatorImpl::UpdateConditionIfNeeded(
     MemoryCondition next_condition) {
   DCHECK(CalledOnValidThread());
 
-  // Discard one tab when the system is under high memory pressure.
-  if (next_condition == MemoryCondition::CRITICAL)
-    DiscardTab();
+  if (next_condition == MemoryCondition::WARNING)
+    OnWarningCondition();
+  else if (next_condition == MemoryCondition::CRITICAL)
+    OnCriticalCondition();
 
   if (memory_condition_ == next_condition)
     return;
 
   MemoryCondition prev_condition = memory_condition_;
   memory_condition_ = next_condition;
 
   TRACE_EVENT2(TRACE_DISABLED_BY_DEFAULT("memory_coordinator"),
                "MemoryCoordinatorImpl::UpdateConditionIfNeeded", "prev",
                MemoryConditionToString(prev_condition), "next",
                MemoryConditionToString(next_condition));
 
   // TODO(bashi): Following actions are tentative. We might want to prioritize
   // processes and handle them one-by-one.
 
   if (next_condition == MemoryCondition::NORMAL) {
     // Set NORMAL state to all clients/processes.
     UpdateBrowserStateAndNotifyStateToClients(MemoryState::NORMAL);
     NotifyStateToChildren(MemoryState::NORMAL);
   } else if (next_condition == MemoryCondition::WARNING) {
     // Set NORMAL state to foreground proceses and clients in the browser
     // process. Set THROTTLED state to background processes.
     UpdateBrowserStateAndNotifyStateToClients(MemoryState::NORMAL);
     for (auto& iter : children()) {
       auto state =
           iter.second.is_visible ? MemoryState::NORMAL : MemoryState::THROTTLED;
       SetChildMemoryState(iter.first, state);
     }
-    // Idea: Purge memory from background processes.
   } else if (next_condition == MemoryCondition::CRITICAL) {
     // Set THROTTLED state to all clients/processes.
     UpdateBrowserStateAndNotifyStateToClients(MemoryState::THROTTLED);
     NotifyStateToChildren(MemoryState::THROTTLED);
   }
 }
 
 void MemoryCoordinatorImpl::DiscardTab() {
   if (delegate_)
     delegate_->DiscardTab();
@@ skipping 56 matching lines @@
                            !render_process_host->IsProcessBackgrounded());
 }
 
 void MemoryCoordinatorImpl::OnChildVisibilityChanged(int render_process_id,
                                                      bool is_visible) {
   auto iter = children().find(render_process_id);
   if (iter == children().end())
     return;
 
   iter->second.is_visible = is_visible;
+  if (!is_visible) {
+    // A backgrounded process becomes a candidate for purging memory when
+    // the process remains backgrounded for a certian period of time.
+    iter->second.can_purge_after =
+        tick_clock_->NowTicks() +
+        base::TimeDelta::FromSeconds(
+            kDefaultBackgroundChildPurgeCandidatePeriodSeconds);
+  }
   MemoryState new_state =
       CalculateMemoryStateForProcess(GetMemoryCondition(), is_visible);
   SetChildMemoryState(render_process_id, new_state);
 }
 
 MemoryState MemoryCoordinatorImpl::OverrideState(MemoryState memory_state,
                                                  const ChildInfo& child) {
   // We don't suspend foreground renderers. Throttle them instead.
   if (child.is_visible && memory_state == MemoryState::SUSPENDED)
     return MemoryState::THROTTLED;
@@ skipping 52 matching lines @@
   base::MemoryCoordinatorClientRegistry::GetInstance()->Notify(state);
 }
 
 void MemoryCoordinatorImpl::NotifyStateToChildren(MemoryState state) {
   // It's OK to call SetChildMemoryState() unconditionally because it checks
   // whether this state transition is valid.
   for (auto& iter : children())
     SetChildMemoryState(iter.first, state);
 }
 
+void MemoryCoordinatorImpl::OnWarningCondition() {
+  TryToPurgeMemoryFromChildren(PurgeTarget::BACKGROUNDED);
+}
+
+void MemoryCoordinatorImpl::OnCriticalCondition() {
+  DiscardTab();
+
+  // Prefer to purge memory from child processes than browser process because
+  // we prioritize the brower process.
+  if (TryToPurgeMemoryFromChildren(PurgeTarget::ALL))
+    return;
+
+  TryToPurgeMemoryFromBrowser();
+}
+
+bool MemoryCoordinatorImpl::TryToPurgeMemoryFromChildren(PurgeTarget target) {
+  base::TimeTicks now = tick_clock_->NowTicks();
+  // TODO(bashi): Better to sort child processes based on their priorities.
+  for (auto& iter : children()) {
+    if (iter.second.is_visible && target == PurgeTarget::BACKGROUNDED)
+      continue;
+    if (!iter.second.can_purge_after.is_null() &&
+        iter.second.can_purge_after > now)
+      continue;
+
+    // Set |can_purge_after| to the maximum value to suppress another purge
+    // request until the child process goes foreground and then goes background
+    // again.
+    iter.second.can_purge_after = base::TimeTicks::Max();
+    iter.second.handle->child()->PurgeMemory();
+    return true;
+  }
+  return false;
+}
+
+bool MemoryCoordinatorImpl::TryToPurgeMemoryFromBrowser() {
+  base::TimeTicks now = tick_clock_->NowTicks();
+  if (can_purge_after_ > now)
+    return false;
+
+  auto metrics = base::ProcessMetrics::CreateCurrentProcessMetrics();
+  size_t before = metrics->GetWorkingSetSize();
+  task_runner_->PostDelayedTask(FROM_HERE,
+                                base::Bind(&RecordBrowserPurge, before),
+                                base::TimeDelta::FromSeconds(2));
+
+  // Suppress purging in the browser process until a certain period of time is
+  // passed.
+  can_purge_after_ = now + base::TimeDelta::FromMinutes(2);
+  base::MemoryCoordinatorClientRegistry::GetInstance()->PurgeMemory();
+  return true;
+}
+
 MemoryCoordinatorImpl::ChildInfo::ChildInfo() {}
 
 MemoryCoordinatorImpl::ChildInfo::ChildInfo(const ChildInfo& rhs) {
   // This is a nop, but exists for compatibility with STL containers.
 }
 
 MemoryCoordinatorImpl::ChildInfo::~ChildInfo() {}
 
 }  // namespace content