TabManager: Set OOM scores via a new debugd interface on ChromeOS.

chrome/browser/memory/tab_manager_delegate_chromeos.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 "chrome/browser/memory/tab_manager_delegate_chromeos.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 14 matching lines @@
 #include "base/synchronization/lock.h"
 #include "base/time/time.h"
 #include "chrome/browser/chromeos/arc/arc_process.h"
 #include "chrome/browser/chromeos/arc/arc_process_service.h"
 #include "chrome/browser/memory/tab_stats.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_features.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/debug_daemon_client.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/arc/common/process.mojom.h"
 #include "components/arc/metrics/oom_kills_histogram.h"
 #include "components/exo/shell_surface.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/zygote_host_linux.h"
@@ skipping 28 matching lines @@
     return false;
   std::string application_id = exo::ShellSurface::GetApplicationId(window);
   return base::StartsWith(application_id, kArcProcessNamePrefix,
                           base::CompareCase::SENSITIVE);
 }
 
 bool IsArcMemoryManagementEnabled() {
   return base::FeatureList::IsEnabled(features::kArcMemoryManagement);
 }
 
+void OnSetOomScoreAdj(bool success, const std::string& output) {
+  VLOG(2) << "OnSetOomScoreAdj " << success << " " << output;
+  if (!success || output != "") {

[Georges Khalil, 2016/08/15 18:47:54]

nit: !output.empty()
nit: no braces

[cylee1, 2016/08/16 19:47:10]

Done.

+    LOG(WARNING) << "Set OOM score error: " << output;
+  }
+}
+
 }  // namespace
 
 std::ostream& operator<<(std::ostream& os, const ProcessType& type) {
   switch (type) {
     case ProcessType::FOCUSED_APP:
       return os << "FOCUSED_APP/FOCUSED_TAB";
     case ProcessType::VISIBLE_APP:
       return os << "VISIBLE_APP";
     case ProcessType::BACKGROUND_APP:
       return os << "BACKGROUND_APP";
@@ skipping 387 matching lines @@
   // The focused process doesn't render a tab. Could happen when the focus
   // just switched to an ARC app. We can not avoid the race.
   if (pid == base::kNullProcessHandle)
     return;
   {
     base::AutoLock oom_score_autolock(oom_score_lock_);
     oom_score_map_[pid] = chrome::kLowestRendererOomScore;
   }
   VLOG(3) << "Set OOM score " << chrome::kLowestRendererOomScore
           << " for focused tab " << pid;
-  content::ZygoteHost::GetInstance()->AdjustRendererOOMScore(
-      pid, chrome::kLowestRendererOomScore);
+  std::map<int, int> dict;
+  dict[pid] = chrome::kLowestRendererOomScore;
+  chromeos::DBusThreadManager::Get()->GetDebugDaemonClient()->SetOomScoreAdj(
+      dict, base::Bind(&OnSetOomScoreAdj));
 }
 
 void TabManagerDelegate::OnFocusTabScoreAdjustmentTimeout() {
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&TabManagerDelegate::AdjustFocusedTabScoreOnFileThread,
                  base::Unretained(this)));
 }
 
 void TabManagerDelegate::AdjustFocusedTabScore(base::ProcessHandle pid) {
@@ skipping 237 matching lines @@
   DistributeOomScoreInRange(candidates.begin(), lower_priority_part,
                             chrome::kLowestRendererOomScore, range_middle,
                             &new_map);
   // Lower priority part.
   DistributeOomScoreInRange(lower_priority_part, candidates.end(), range_middle,
                             chrome::kHighestRendererOomScore, &new_map);
   base::AutoLock oom_score_autolock(oom_score_lock_);
   oom_score_map_.swap(new_map);
 }
 
-void TabManagerDelegate::SetOomScoreAdjForApp(int nspid, int score) {
-  if (!arc_process_instance_)
-    return;
-  if (arc_process_instance_version_ < 2) {
-    VLOG(1) << "ProcessInstance version < 2 does not "
-               "support SetOomScoreAdj() yet.";
-    return;
-  }
-  arc_process_instance_->SetOomScoreAdj(nspid, score);
-}
-
-void TabManagerDelegate::SetOomScoreAdjForTabs(
+void TabManagerDelegate::SetOomScoreAdj(
     const std::vector<std::pair<base::ProcessHandle, int>>& entries) {
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
-      base::Bind(&TabManagerDelegate::SetOomScoreAdjForTabsOnFileThread,
+      base::Bind(&TabManagerDelegate::SetOomScoreAdjOnFileThread,
                  base::Unretained(this), entries));
 }
 
-void TabManagerDelegate::SetOomScoreAdjForTabsOnFileThread(
+// XXX: In the past it writes to procfs directly so running in file thread.
+// Now it talks to debugd via DBus and the write is done in debugd
+// asynchronously. Consider moving it back to UI thread.
+void TabManagerDelegate::SetOomScoreAdjOnFileThread(
     const std::vector<std::pair<base::ProcessHandle, int>>& entries) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
-  for (const auto& entry : entries) {
-    content::ZygoteHost::GetInstance()->AdjustRendererOOMScore(entry.first,
-                                                               entry.second);
-  }
+
+  std::map<int, int> dict;
+  // Ignore duplicated keys but the last occurrence.
+  for (const auto& entry : entries)
+    dict[entry.first] = entry.second;
+  chromeos::DBusThreadManager::Get()->GetDebugDaemonClient()->SetOomScoreAdj(

[hashimoto, 2016/08/15 03:54:23]

D-Bus clients are not thread-safe.
They must be accessed only on the UI thread.

[cylee1, 2016/08/16 19:47:10]

Done.

+      dict, base::Bind(&OnSetOomScoreAdj));
 }
 
 void TabManagerDelegate::DistributeOomScoreInRange(
     std::vector<TabManagerDelegate::Candidate>::const_iterator begin,
     std::vector<TabManagerDelegate::Candidate>::const_iterator end,
     int range_begin,
     int range_end,
     ProcessScoreMap* new_map) {
-  // OOM score setting for tabs involves file system operation so should be
-  // done on file thread.
-  std::vector<std::pair<base::ProcessHandle, int>> oom_score_for_tabs;
+  std::vector<std::pair<base::ProcessHandle, int>> oom_scores_to_change;
 
   // Though there might be duplicate process handles, it doesn't matter to
   // overestimate the number of processes here since the we don't need to
   // use up the full range.
   int num = (end - begin);
   const float priority_increment =
       static_cast<float>(range_end - range_begin) / num;
 
   float priority = range_begin;
   for (auto cur = begin; cur != end; ++cur) {
     int score = static_cast<int>(priority + 0.5f);
     if (cur->app()) {
+      base::ProcessHandle pid = cur->app()->pid();
       // Use pid as map keys so it's globally unique.
-      (*new_map)[cur->app()->pid()] = score;
+      (*new_map)[pid] = score;
       int cur_app_pid_score = 0;
       {
         base::AutoLock oom_score_autolock(oom_score_lock_);
-        cur_app_pid_score = oom_score_map_[cur->app()->pid()];
+        cur_app_pid_score = oom_score_map_[pid];
       }
       if (cur_app_pid_score != score) {
         VLOG(3) << "Set OOM score " << score << " for " << *cur;
-        SetOomScoreAdjForApp(cur->app()->nspid(), score);
+        oom_scores_to_change.push_back(std::make_pair(pid, score));
       }
     } else {
       base::ProcessHandle process_handle = cur->tab()->renderer_handle;
       // 1. tab_list contains entries for already-discarded tabs. If the PID
       // (renderer_handle) is zero, we don't need to adjust the oom_score.
       // 2. Only add unseen process handle so if there's multiple tab maps to
       // the same process, the process is set to an OOM score based on its "most
       // important" tab.
       if (process_handle != 0 &&
           new_map->find(process_handle) == new_map->end()) {
         (*new_map)[process_handle] = score;
         int process_handle_score = 0;
         {
           base::AutoLock oom_score_autolock(oom_score_lock_);
           process_handle_score = oom_score_map_[process_handle];
         }
         if (process_handle_score != score) {
-          oom_score_for_tabs.push_back(std::make_pair(process_handle, score));
           VLOG(3) << "Set OOM score " << score << " for " << *cur;
+          oom_scores_to_change.push_back(std::make_pair(process_handle, score));
         }
       } else {
         continue;  // Skip priority increment.
       }
     }
     priority += priority_increment;
   }
 
-  if (oom_score_for_tabs.size())
-    SetOomScoreAdjForTabs(oom_score_for_tabs);
+  if (oom_scores_to_change.size())
+    SetOomScoreAdj(oom_scores_to_change);
 }
 
 }  // namespace memory