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)

[haraken, 2017/03/24 11:55:39]

Maybe we want to record this case too. See my comment in render_thread_impl.

[bashi, 2017/03/28 03:15:31]

Acknowledged.

+    return;
+  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 57 matching lines @@
 
 MemoryCoordinatorImpl::MemoryCoordinatorImpl(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     std::unique_ptr<MemoryMonitor> memory_monitor)
     : task_runner_(task_runner),
       delegate_(GetContentClient()->browser()->GetMemoryCoordinatorDelegate()),
       memory_monitor_(std::move(memory_monitor)),
       condition_observer_(
           base::MakeUnique<MemoryConditionObserver>(this, task_runner)),
       tick_clock_(base::MakeUnique<base::DefaultTickClock>()),
-      minimum_state_transition_period_(base::TimeDelta::FromSeconds(
-          kDefaultMinimumTransitionPeriodSeconds)) {
+      minimum_state_transition_period_(
+          base::TimeDelta::FromSeconds(kDefaultMinimumTransitionPeriodSeconds)),
+      background_child_purge_candidate_period_(base::TimeDelta::FromSeconds(
+          kDefaultBackgroundChildPurgeCandidatePeriodSeconds)) {
   DCHECK(memory_monitor_.get());
   base::MemoryCoordinatorProxy::SetMemoryCoordinator(this);
 
   // Force the "memory_coordinator" category to show up in the trace viewer.
   base::trace_event::TraceLog::GetCategoryGroupEnabled(
       TRACE_DISABLED_BY_DEFAULT("memory_coordinator"));
 }
 
 MemoryCoordinatorImpl::~MemoryCoordinatorImpl() {
   base::MemoryCoordinatorProxy::SetMemoryCoordinator(nullptr);
@@ skipping 109 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::WARNING)
+    OnWarningCondition();
+
   if (next_condition == MemoryCondition::CRITICAL)

[haraken, 2017/03/24 11:55:39]

else if

[bashi, 2017/03/28 03:15:31]

Done.

-    DiscardTab();
+    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() {
+bool MemoryCoordinatorImpl::DiscardTab() {
   if (delegate_)
-    delegate_->DiscardTab();
+    return delegate_->DiscardTab();
+  return false;
 }
 
 RenderProcessHost* MemoryCoordinatorImpl::GetRenderProcessHost(
     int render_process_id) {
   return RenderProcessHost::FromID(render_process_id);
 }
 
 void MemoryCoordinatorImpl::SetDelegateForTesting(
     std::unique_ptr<MemoryCoordinatorDelegate> delegate) {
   CHECK(!delegate_);
@@ skipping 46 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() + background_child_purge_candidate_period_;

[haraken, 2017/03/24 11:55:39]

Maybe you can inline
base::TimeDelta::FromSeconds(kDefaultBackgroundChildPurgeCandidatePeriodSeconds)
and remove background_child_purge_candidate_period_.

[bashi, 2017/03/28 03:15:31]

Done.

+  }
   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() {
+  TryPurgeMemoryFromChildren(PurgeTarget::BACKGROUNDED);
+}
+
+void MemoryCoordinatorImpl::OnCriticalCondition() {
+  // Prefer to discard a tab rather than purging memory on critical condition
+  // to mitigate a risk to cause thrashing.
+  if (DiscardTab())
+    return;
+
+  if (TryPurgeMemoryFromChildren(PurgeTarget::ALL))

[haraken, 2017/03/24 11:55:39]

Add:

  // Prefer purging memory from child processes than the browser process because
...

[bashi, 2017/03/28 03:15:31]

Done.

+    return;
+
+  TryPurgeMemoryFromBrowser();
+}
+
+bool MemoryCoordinatorImpl::TryPurgeMemoryFromChildren(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() &&

[haraken, 2017/03/24 11:55:38]

I'd prefer initializing can_purge_after to base::TimeTicks::Max() and dropping
the null check.

[bashi, 2017/03/28 03:15:31]

Using Max() as the initial value is slightly different from using null value as
the initial value. If we use Max(), a tab won't become a candidate until it goes
background. I'd prefer to make foreground tabs be candidates of purging memory
in CRITICAL condition.

+        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::TryPurgeMemoryFromBrowser() {
+  base::TimeTicks now = tick_clock_->NowTicks();
+  if (!can_purge_after_.is_null() && can_purge_after_ > now)

[haraken, 2017/03/24 11:55:38]

Remove the null check.

[bashi, 2017/03/28 03:15:31]

Done.

+    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