mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-04 11:23:34 +00:00
a203b827db
This patch implements hal::SetProcessPriority() on Linux and leverages it to make it more likely that the parent process and foreground tab survive an OOM situation, letting Linux' OOM killer reap preallocated processes and background tabs first when reclaiming memory. This is achieved by setting the `oom_score_adj` values of said processes such that they will be killed in this order: * Preallocated processes will be the first to go, they don't contain user data and are not visible, so they're a good candidate to free up memory * Background tabs will be killed next, we don't generate crash reports for thoes nor do we inform the user, we just reload the tab, so in most cases one being killed will only be a small annoyance * Background tabs playing video come next, but only if they're not also playing or recording audio * Finally foreground tabs will be killed as a last resort, background tabs playing audio or with an active WebRTC session are also considered to be in the foreground as the user will immediately notice if they crash Note that this patch only implements the low-level plumbing. The process priority manager has not been enabled on Linux yet so that needs to happen before this actually works. Differential Revision: https://phabricator.services.mozilla.com/D153466
79 lines
2.6 KiB
C++
79 lines
2.6 KiB
C++
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
* You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "Hal.h"
|
|
#include "HalLog.h"
|
|
|
|
#include "mozilla/Sprintf.h"
|
|
#include "mozilla/Unused.h"
|
|
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
|
|
using namespace mozilla::hal;
|
|
|
|
namespace mozilla::hal_impl {
|
|
|
|
/* The Linux OOM score is a value computed by the kernel ranging between 0 and
|
|
* 1000 and indicating how likely is a process to be killed when memory is
|
|
* tight. The larger the value the more likely a process is to be killed. The
|
|
* score is computed based on the amount of memory used plus an adjustment
|
|
* value. We chose our adjustment values to make it likely that processes are
|
|
* killed in the following order:
|
|
*
|
|
* 1. preallocated processes
|
|
* 2. background processes
|
|
* 3. background processes playing video (but no audio)
|
|
* 4. foreground processes or processes playing or recording audio
|
|
* 5. the parent process
|
|
*
|
|
* At the time of writing (2022) the base score for a process consuming very
|
|
* little memory seems to be around ~667. Our adjustments are thus designed
|
|
* to ensure this order starting from a 667 baseline but trying not to go too
|
|
* close to the 1000 limit where they would be clamped. */
|
|
|
|
const uint32_t kParentOomScoreAdjust = 0;
|
|
const uint32_t kForegroundOomScoreAdjust = 100;
|
|
const uint32_t kBackgroundPerceivableOomScoreAdjust = 133;
|
|
const uint32_t kBackgroundOomScoreAdjust = 167;
|
|
const uint32_t kPreallocOomScoreAdjust = 233;
|
|
|
|
static uint32_t OomScoreAdjForPriority(ProcessPriority aPriority) {
|
|
switch (aPriority) {
|
|
case PROCESS_PRIORITY_BACKGROUND:
|
|
return kBackgroundOomScoreAdjust;
|
|
case PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE:
|
|
return kBackgroundPerceivableOomScoreAdjust;
|
|
case PROCESS_PRIORITY_PREALLOC:
|
|
return kPreallocOomScoreAdjust;
|
|
case PROCESS_PRIORITY_FOREGROUND:
|
|
return kForegroundOomScoreAdjust;
|
|
default:
|
|
return kParentOomScoreAdjust;
|
|
}
|
|
}
|
|
|
|
void SetProcessPriority(int aPid, ProcessPriority aPriority) {
|
|
HAL_LOG("LinuxProcessPriority - SetProcessPriority(%d, %s)\n", aPid,
|
|
ProcessPriorityToString(aPriority));
|
|
|
|
uint32_t oomScoreAdj = OomScoreAdjForPriority(aPriority);
|
|
|
|
char path[32] = {};
|
|
SprintfLiteral(path, "/proc/%d/oom_score_adj", aPid);
|
|
|
|
char oomScoreAdjStr[11] = {};
|
|
SprintfLiteral(oomScoreAdjStr, "%d", oomScoreAdj);
|
|
|
|
int fd = open(path, O_WRONLY);
|
|
if (fd < 0) {
|
|
return;
|
|
}
|
|
const size_t len = strlen(oomScoreAdjStr);
|
|
Unused << write(fd, oomScoreAdjStr, len);
|
|
Unused << close(fd);
|
|
}
|
|
|
|
} // namespace mozilla::hal_impl
|