TabManagerDelegate: Better prioritize ARC processes.

chrome/browser/memory/tab_manager_delegate_chromeos.h

 // 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.
 
 #ifndef CHROME_BROWSER_MEMORY_TAB_MANAGER_DELEGATE_CHROMEOS_H_
 #define CHROME_BROWSER_MEMORY_TAB_MANAGER_DELEGATE_CHROMEOS_H_
 
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
+#include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/process/process.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/chromeos/arc/arc_process.h"
+#include "chrome/browser/memory/arc_process_adj_level.h"
 #include "chrome/browser/memory/tab_manager.h"
 #include "chrome/browser/memory/tab_stats.h"
 #include "chrome/browser/ui/browser_list_observer.h"
 #include "components/arc/arc_bridge_service.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "ui/wm/public/activation_change_observer.h"
 
 namespace memory {
 
-// The importance of tabs/apps. The lower the value, the more likely a process
-// is to be selected on memory pressure. The values is additive, for example,
-// one tab could be of value (CHROME_NORMAL | CHROME_PINNED).
-// TODO(cylee): Refactor this CL so the prioritize logic is unified in
-// TabManager.
-enum ProcessPriority {
-  // Processes on Android side which generally don't have an app window, and
-  // possibly be auto relaunched if killed.
-  ANDROID_BACKGROUND = 1,
-  ANDROID_SERVICE = 1 << 1,
-  ANDROID_CANT_SAVE_STATE = 1 << 2,
-  ANDROID_PERCEPTIBLE = 1 << 3,
-  ANDROID_VISIBLE = 1 << 4,
-  ANDROID_TOP_SLEEPING = 1 << 5,
-  ANDROID_FOREGROUND_SERVICE = 1 << 6,
-  ANDROID_FOREGROUND = 1 << 7,
-  // A chrome window can be one of the 3 exclusive types below:
-  // internal page, normal page, or chrome app.
-  CHROME_INTERNAL = 1 << 8,
-  CHROME_NORMAL = 1 << 9,
-  CHROME_APP = 1 << 10,
-  // An android app which is on top of screen from Android's point of view,
-  // but the app window is inactive from Chrome OS's point of view.
-  // Give it a higher priority then normal chrome tab since it could not be
-  // reloaded if killed.
-  ANDROID_TOP_INACTIVE = CHROME_APP,
-  // A chrome tab could have following 3 additional attributes
-  // (not exclusive).
-  CHROME_PINNED = 1 << 11,
-  CHROME_MEDIA = 1 << 12,
-  CHROME_CANT_SAVE_STATE = 1 << 13,
-  // The highest level of priority. Either a selected tab or an Android app in
-  // an active window. In theory there should be at most one process with this
-  // priority at a time, but at the time of writing Chrome couldn't get Android
-  // window stack info yet so there may be multiple Android apps be token as on
-  // top of screen for now.
-  CHROME_SELECTED = 1 << 14,
-  ANDROID_TOP = CHROME_SELECTED,
+// Possible types of Apps/Tabs processes. From most important to least
+// important.
+enum ProcessType {
+  // There can be only one process having process type "FOCUSED_APP"
+  // or "FOCUSED_TAB" in the system at any give time (i.e., The focused window
+  // could be either a chrome window or an Android app. But not both.
+  FOCUSED_APP = 1,
+  FOCUSED_TAB = FOCUSED_APP,
 
-  ANDROID_PERSISTENT = 1 << 30,
-  ANDROID_NON_EXISTS = 0x7FFFFFFF
+  VISIBLE_APP = 2,
+  BACKGROUND_TAB = 3,
+  BACKGROUND_APP = 4,
+  UNKNOWN_TYPE = 5,
 };
 
 // The Chrome OS TabManagerDelegate is responsible for keeping the
 // renderers' scores up to date in /proc/<pid>/oom_score_adj.
 //
 // Note that AdjustOomPriorities will be called on the UI thread by
 // TabManager, but the actual work will take place on the file thread
 // (see implementation of AdjustOomPriorities).
 class TabManagerDelegate : public arc::ArcBridgeService::Observer,
                            public aura::client::ActivationChangeObserver,
@@ skipping 45 matching lines @@
 
   // Kills a tab. Returns true if the tab is killed successfully.
   // Virtual for unit testing.
   virtual bool KillTab(int64_t tab_id);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(TabManagerDelegateTest, CandidatesSorted);
   FRIEND_TEST_ALL_PREFIXES(TabManagerDelegateTest, KillMultipleProcesses);
   FRIEND_TEST_ALL_PREFIXES(TabManagerDelegateTest, SetOomScoreAdj);
 
-  struct Candidate;
+  class Candidate;
   class FocusedProcess;
   class UmaReporter;
 
   friend std::ostream& operator<<(
       std::ostream& out, const Candidate& candidate);
 
   // content::NotificationObserver:
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override;
 
   // Pair to hold child process host id and ProcessHandle.
   typedef std::pair<int, base::ProcessHandle> ProcessInfo;
 
   // Cache OOM scores in memory.
   typedef base::hash_map<base::ProcessHandle, int> ProcessScoreMap;
 
-  // Get the list of candidates to kill, sorted by reversed importance.
+  // Get the list of candidates to kill, sorted by importance descendingly.
   static std::vector<Candidate> GetSortedCandidates(
       const TabStatsList& tab_list,
       const std::vector<arc::ArcProcess>& arc_processes);
 
   // Posts AdjustFocusedTabScore task to the file thread.
   void OnFocusTabScoreAdjustmentTimeout();
 
   // Kills a process after getting all info of tabs and apps.
   void LowMemoryKillImpl(const TabStatsList& tab_list,
                          const std::vector<arc::ArcProcess>& arc_processes);
@@ skipping 17 matching lines @@
   void SetOomScoreAdjForApp(int nspid, int score);
 
   // Sets oom_score_adj for a list of tabs on the file thread.
   void SetOomScoreAdjForTabsOnFileThread(
       const std::vector<std::pair<base::ProcessHandle, int>>& entries);
 
   // Sets OOM score for processes in the range [|rbegin|, |rend|) to integers
   // distributed evenly in [|range_begin|, |range_end|).
   // The new score is set in |new_map|.
   void DistributeOomScoreInRange(
-      std::vector<TabManagerDelegate::Candidate>::reverse_iterator rbegin,
-      std::vector<TabManagerDelegate::Candidate>::reverse_iterator rend,
+      std::vector<TabManagerDelegate::Candidate>::const_iterator begin,
+      std::vector<TabManagerDelegate::Candidate>::const_iterator end,
       int range_begin,
       int range_end,
       ProcessScoreMap* new_map);
 
   // Initiates an oom priority adjustment.
   void ScheduleEarlyOomPrioritiesAdjustment();
 
   // Holds a reference to the owning TabManager.
   const base::WeakPtr<TabManager> tab_manager_;
 
@@ skipping 24 matching lines @@
   // Reports UMA histograms.
   std::unique_ptr<UmaReporter> uma_;
 
   // Weak pointer factory used for posting tasks to other threads.
   base::WeakPtrFactory<TabManagerDelegate> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TabManagerDelegate);
 };
 
 // On ARC enabled machines, either a tab or an app could be a possible
-// victim of low memory kill process. This is a helper struct which holds a
+// victim of low memory kill process. This is a helper class which holds a
 // pointer to an app or a tab (but not both) to facilitate prioritizing the
 // victims.
-struct TabManagerDelegate::Candidate {
-  Candidate(const TabStats* _tab, int _priority)
-      : tab(_tab), priority(_priority), is_arc_app(false) {}
-  Candidate(const arc::ArcProcess* _app, int _priority)
-      : app(_app), priority(_priority), is_arc_app(true) {}
-
-  bool operator<(const Candidate& rhs) const {
-    return priority < rhs.priority;
+class TabManagerDelegate::Candidate {
+ public:
+  explicit Candidate(const TabStats* tab)
+      : tab_(tab), app_(NULL), process_type_(GetProcessType()) {

[Georges Khalil, 2016/06/27 20:15:05]

nit: NULL -> nullptr.

[cylee1, 2016/07/14 19:15:24]

Done.

+  }
+  explicit Candidate(const arc::ArcProcess* app)
+      : tab_(NULL), app_(app), process_type_(GetProcessType()) {

[Georges Khalil, 2016/06/27 20:15:05]

nit: same as above.

[cylee1, 2016/07/14 19:15:25]

Done.

   }
 
-  union {
-    const TabStats* tab;
-    const arc::ArcProcess* app;
-  };
-  int priority;
-  bool is_arc_app;
+  // Higher priority first.
+  bool operator<(const Candidate& rhs) const {
+    if (app() && rhs.app()) {
+      // Sort by (adj, last_activity_time) pair.
+      // Larger adj value means lower priority as defined in Android.
+      if (app()->adj() != rhs.app()->adj())

[Luis Héctor Chávez, 2016/06/28 15:43:53]

You can replace all this by:

// Larger adj value means lower priority as defined in Android.
return std::tie(-app()->adj(), app()->last_activity_time()) >
    std::tie(-rhs.app()->adj(), rhs.app()->last_activity_time());

[cylee1, 2016/07/14 19:15:24]

tie() requires non-const reference since it expects lvalue (so can be used as
unpack). make_pair() seems to work as intended.
http://stackoverflow.com/questions/5367707/invalid-initialization-error

+        return app()->adj() < rhs.app()->adj();
+      // LRU manner.
+      return app()->last_activity_time() > rhs.app()->last_activity_time();
+    } else if (tab() && rhs.tab()) {
+      return TabManager::CompareTabStats(*tab(), *rhs.tab());
+    }
+    // If one is tab and the other is Android app, simply sort by their process
+    // type for now.
+    return process_type() < rhs.process_type();
+  }
+
+  const TabStats* tab() const { return tab_; }
+  const arc::ArcProcess* app() const { return app_; }
+  ProcessType process_type() const { return process_type_; }
+
+ private:
+  ProcessType GetProcessType() {
+    if (app()) {
+      if (app()->adj() == ArcProcessAdjLevel::FOREGROUND_APP_ADJ) {
+        return ProcessType::FOCUSED_APP;
+      } else if (app()->adj() == ArcProcessAdjLevel::VISIBLE_APP_ADJ) {

[Georges Khalil, 2016/06/27 20:15:05]

nit: No need for else here. Also allows the removal of curly braces.

[cylee1, 2016/07/14 19:15:24]

Done.

+        return ProcessType::VISIBLE_APP;
+      }
+      return ProcessType::BACKGROUND_APP;
+    } else if (tab()) {
+      if (tab()->is_selected) {
+        return ProcessType::FOCUSED_TAB;

[Georges Khalil, 2016/06/27 20:15:05]

nit: no braces.

[cylee1, 2016/07/14 19:15:25]

Done.

+      }
+      return ProcessType::BACKGROUND_TAB;
+    }
+    NOTREACHED() << "Unexpected process type";
+    return ProcessType::UNKNOWN_TYPE;
+  }
+
+  const TabStats* tab_;
+  const arc::ArcProcess* app_;
+  ProcessType process_type_;
 };
 
 // A thin wrapper over library process_metric.h to get memory status so unit
 // test get a chance to mock out.
 class TabManagerDelegate::MemoryStat {
  public:
   MemoryStat() {}
   virtual ~MemoryStat() {}
 
   // Returns target size of memory to free given current memory pressure and
   // pre-configured low memory margin.
   virtual int TargetMemoryToFreeKB();
 
   // Returns estimated memory to be freed if the process |pid| is killed.
   virtual int EstimatedMemoryFreedKB(base::ProcessHandle pid);
 
  private:
   // Returns the low memory margin system config. Low memory condition is
   // reported if available memory is under the number.
   static int LowMemoryMarginKB();
 
   // Reads in an integer.
   static int ReadIntFromFile(const char* file_name, int default_val);
 };
 
 }  // namespace memory
 
 #endif  // CHROME_BROWSER_MEMORY_TAB_MANAGER_DELEGATE_CHROMEOS_H_