Changing OOM range to 0, 1000 and tweaking OOM algorithm.

chrome/app/chrome_main.cc

 // Copyright (c) 2011 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/app/chrome_main.h"
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/debug/debugger.h"
 #include "base/i18n/icu_util.h"
@@ skipping 155 matching lines @@
   // We are only searching for ASCII characters so this is OK.
   StringToLowerASCII(&command_line_lower);
   std::wstring::size_type pos = command_line_lower.find(kChromeHtml);
   return (pos != std::wstring::npos);
 }
 
 #endif  // defined(OS_WIN)
 
 #if defined(OS_LINUX)
 static void AdjustLinuxOOMScore(const std::string& process_type) {
-  const int kMiscScore = 7;
-#if defined(OS_CHROMEOS)
-  // On ChromeOS, we want plugins to die after the renderers.  If this
-  // works well for ChromeOS, we may do it for Linux as well.
-  const int kPluginScore = 4;
-#else
-  const int kPluginScore = 10;
-#endif
+  // Browsers and zygotes should still be killable, but killed last.
+  const int kZygoteScore = 0;
+  // This is the lowest score that renderers and extensions start with
+  // in the OomPriorityManager.
+  const int kRendererScore = chrome::kLowestRendererOomScore;
+  // We want plugins to die after the renderers.
+  const int kPluginScore = 100;

[stevenjb, 2011/08/18 23:31:05]

Really, I'm not trying to be a pain :), but I think this should either be
defined with kLowestRendererOomScore, or relative to it (i.e. kRendererScore -
200, kRendererScore - 100 for kMiscScore)

[Greg Spencer (Chromium), 2011/08/18 23:59:32]

No worries: good comments are never a pain.

OK, I can define it relative, but should be less than the lowest renderer:
that's kind of the point.

(So, you're OK with a "- 100", but not with an average? :) )

[stevenjb, 2011/08/19 17:25:31]

The question is, an average of what? With absolute scores there is an implicit
knowledge that chrome::kLowestRendererOomScore == 300. At least with deltas, as
long as chrome::kLowestRendererOomScore > 200 the logic works. The DCHECKs are a
good addition and avoid the need to define these in the header with
kLowestRendererOomScore.

+  // For "miscellaneous" things, we want them after renderers,
+  // but before plugins.
+  const int kMiscScore = 200;
+  // The minimum amount to bump a score by.  This is large enough that
+  // even if it's translated into the old values, it will still go up
+  // by at least one.
+  const int kMinScoreBump = 100;
   int score = -1;
 
   if (process_type == switches::kPluginProcess ||
       process_type == switches::kPpapiPluginProcess) {
     score = kPluginScore;
   } else if (process_type == switches::kPpapiBrokerProcess) {
-    // Kill the broker before the plugin.
-    score = kPluginScore + 1;
+    // The broker should be killed before the PPAPI plugin.
+    score = kPluginScore + kMinScoreBump;
   } else if (process_type == switches::kUtilityProcess ||
              process_type == switches::kWorkerProcess ||
              process_type == switches::kGpuProcess ||
              process_type == switches::kServiceProcess) {
     score = kMiscScore;
   } else if (process_type == switches::kProfileImportProcess) {
     NOTIMPLEMENTED();
+    score = kZygoteScore;
 #ifndef DISABLE_NACL
   } else if (process_type == switches::kNaClLoaderProcess) {
     score = kPluginScore;
 #endif
   } else if (process_type == switches::kZygoteProcess ||
              process_type.empty()) {
-    // Pass - browser / zygote process stays at 0.
+    // For zygotes and unlabeled process types, we want to still make
+    // them killable by the OOM killer.
+    score = kZygoteScore;
   } else if (process_type == switches::kExtensionProcess ||
              process_type == switches::kRendererProcess) {
     LOG(WARNING) << "process type '" << process_type << "' "
-                 << "should go through the zygote.";
-    // When debugging, these process types can end up being run directly.
-    return;
+                 << "should be created through the zygote.";
+    // When debugging, these process types can end up being run
+    // directly, but this isn't the typical path for assigning the OOM
+    // score for them.  Still, we want to assign a score that is
+    // somewhat representative for debugging.
+    score = kRendererScore;
   } else {
     NOTREACHED() << "Unknown process type";
   }
   if (score > -1)
     base::AdjustOOMScore(base::GetCurrentProcId(), score);
 }
 #endif  // defined(OS_LINUX)
 
 void SetupCRT(const CommandLine& command_line) {
 #if defined(OS_WIN)
-#ifdef _CRTDBG_MAP_ALLOC
+#if defined(_CRTDBG_MAP_ALLOC)
   _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
   _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
 #else
   if (!command_line.HasSwitch(switches::kDisableBreakpad)) {
     _CrtSetReportMode(_CRT_ASSERT, 0);
   }
 #endif
 #endif
 }
 
@@ skipping 294 matching lines @@
     { switches::kGpuProcess,         GpuMain },
     { switches::kServiceProcess,     ServiceProcessMain },
 
 #if defined(OS_MACOSX)
     // TODO(port): Use OOP profile import - http://crbug.com/22142 .
     { switches::kProfileImportProcess, ProfileImportMain },
     { switches::kRelauncherProcess,  mac_relauncher::internal::RelauncherMain },
 #endif
 #if !defined(DISABLE_NACL)
     { switches::kNaClLoaderProcess, NaClMain },
-#ifdef _WIN64  // The broker process is used only on Win64.
+#if defined(_WIN64)  // The broker process is used only on Win64.
     { switches::kNaClBrokerProcess, NaClBrokerMain },
 #endif
 #endif  // DISABLE_NACL
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
     // Zygote startup is special -- see RunZygote comments above
     // for why we don't use ZygoteMain directly.
     { switches::kZygoteProcess, RunZygote },
 #endif
   };
 
@@ skipping 344 matching lines @@
 
   if (SubprocessNeedsResourceBundle(process_type))
     ResourceBundle::CleanupSharedInstance();
 
   logging::CleanupChromeLogging();
 
   chrome_main::LowLevelShutdown();
 
   return exit_code;
 }