TabManager: Take min_free_kbytes into consideration when killing tabs.

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 <stdint.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 233 matching lines @@
   return ReadIntFromFile(
       kLowMemoryMarginConfig, kDefaultLowMemoryMarginMb) * 1024;
 }
 
 // The logic of available memory calculation is copied from
 // _is_low_mem_situation() in kernel file include/linux/low-mem-notify.h.
 // Maybe we should let kernel report the number directly.
 int TabManagerDelegate::MemoryStat::TargetMemoryToFreeKB() {
   static const int kRamVsSwapWeight = 4;
   static const char kMinFilelistConfig[] = "/proc/sys/vm/min_filelist_kbytes";
+  static const char kMinFreeKbytes[] = "/proc/sys/vm/min_free_kbytes";
 
   base::SystemMemoryInfoKB system_mem;
   base::GetSystemMemoryInfo(&system_mem);
   const int file_mem_kb = system_mem.active_file + system_mem.inactive_file;
   const int min_filelist_kb = ReadIntFromFile(kMinFilelistConfig, 0);
+  const int min_free_kb = ReadIntFromFile(kMinFreeKbytes, 0);
   // Calculate current available memory in system.
   // File-backed memory should be easy to reclaim, unless they're dirty.
+  // TODO(cylee): On ChromeOS, kernel reports low memory condition when
+  // available memory is low. The following formula duplicates the logic in
+  // kernel to calculate how much memory should be released. In the future,
+  // kernel should try to report the amount of memory to release directly to
+  // eliminate the duplication here.

[sonnyrao, 2017/01/05 00:24:26]

that's an interesting idea -- does Chrome have the ability to free up arbitrary
amounts of memory or is it just going to discard tabs until it reaches that
number?

[cylee1, 2017/01/05 20:31:13]

Of course it just tries to discard tabs until the estimated RSS to be released
reaches the number :)
And yes, I think I should consolidate the logic in kernel.

   const int available_mem_kb = system_mem.free +
       file_mem_kb - system_mem.dirty - min_filelist_kb +
-      system_mem.swap_free / kRamVsSwapWeight;
+      system_mem.swap_free / kRamVsSwapWeight -
+      min_free_kb;
 
   return LowMemoryMarginKB() - available_mem_kb;
 }
 
 int TabManagerDelegate::MemoryStat::EstimatedMemoryFreedKB(
     base::ProcessHandle pid) {
   std::unique_ptr<base::ProcessMetrics> process_metrics(
       base::ProcessMetrics::CreateProcessMetrics(pid));
   base::WorkingSetKBytes mem_usage;
   process_metrics->GetWorkingSetKBytes(&mem_usage);
@@ skipping 296 matching lines @@
 
 
 chromeos::DebugDaemonClient* TabManagerDelegate::GetDebugDaemonClient() {
   return chromeos::DBusThreadManager::Get()->GetDebugDaemonClient();
 }
 
 void TabManagerDelegate::LowMemoryKillImpl(
     const TabStatsList& tab_list,
     const std::vector<arc::ArcProcess>& arc_processes) {
 
-  VLOG(2) << "LowMemoryKilleImpl";
+  VLOG(2) << "LowMemoryKillImpl";
+
   const std::vector<TabManagerDelegate::Candidate> candidates =
       GetSortedCandidates(tab_list, arc_processes);
 
   int target_memory_to_free_kb = mem_stat_->TargetMemoryToFreeKB();
   // Kill processes until the estimated amount of freed memory is sufficient to
   // bring the system memory back to a normal level.
   // The list is sorted by descending importance, so we go through the list
   // backwards.
   for (auto it = candidates.rbegin(); it != candidates.rend(); ++it) {
     VLOG(3) << "Target memory to free: " << target_memory_to_free_kb << " KB";
@@ skipping 127 matching lines @@
     }
     priority += priority_increment;
   }
 
   if (oom_scores_to_change.size())
     GetDebugDaemonClient()->SetOomScoreAdj(
         oom_scores_to_change, base::Bind(&OnSetOomScoreAdj));
 }
 
 }  // namespace memory