mirror of
https://github.com/mozilla/gecko-dev.git
synced 2025-04-03 04:52:54 +00:00
Bug 822325: Implement an LRU pool for background app processes. The LRU app will get the smallest oom_adj and get killed last. r=khuey
This commit is contained in:
Alan Huang
parent
4975798735
commit
f36c0848bb
@ -603,6 +603,11 @@ pref("dom.ipc.processPriorityManager.enabled", true);
|
||||
pref("dom.ipc.processPriorityManager.backgroundGracePeriodMS", 1000);
|
||||
pref("dom.ipc.processPriorityManager.temporaryPriorityLockMS", 5000);
|
||||
|
||||
// Number of different background levels for background processes. We use
|
||||
// these different levels to force the low-memory killer to kill processes in
|
||||
// a LRU order.
|
||||
pref("dom.ipc.processPriorityManager.backgroundLRUPoolLevels", 5);
|
||||
|
||||
// Kernel parameters for process priorities. These affect how processes are
|
||||
// killed on low-memory and their relative CPU priorities.
|
||||
//
|
||||
|
||||
@ -46,6 +46,7 @@ const browserElementTestHelpers = {
|
||||
enableProcessPriorityManager: function() {
|
||||
this._setPref('dom.ipc.processPriorityManager.testMode', true);
|
||||
this._setPref('dom.ipc.processPriorityManager.enabled', true);
|
||||
this._setPref('dom.ipc.processPriorityManager.backgroundLRUPoolLevels', 2);
|
||||
},
|
||||
|
||||
setEnabledPref: function(value) {
|
||||
@ -193,6 +194,37 @@ function expectPriorityChange(childID, expectedPriority,
|
||||
return deferred.promise;
|
||||
}
|
||||
|
||||
// Returns a promise which is resolved or rejected the next time the background
|
||||
// process childID changes its priority. We resolve if the backgroundLRU
|
||||
// matches expectedBackgroundLRU and we reject otherwise.
|
||||
|
||||
function expectPriorityWithBackgroundLRUSet(childID, expectedBackgroundLRU) {
|
||||
var deferred = Promise.defer();
|
||||
|
||||
browserElementTestHelpers.addProcessPriorityObserver(
|
||||
'process-priority-with-background-LRU-set',
|
||||
function(subject, topic, data) {
|
||||
|
||||
[id, priority, cpuPriority, backgroundLRU] = data.split(":");
|
||||
if (id != childID) {
|
||||
return;
|
||||
}
|
||||
|
||||
is(backgroundLRU, expectedBackgroundLRU,
|
||||
'Expected backgroundLRU ' + backgroundLRU + ' of childID ' + childID +
|
||||
' to change to ' + expectedBackgroundLRU);
|
||||
|
||||
if (backgroundLRU == expectedBackgroundLRU) {
|
||||
deferred.resolve();
|
||||
} else {
|
||||
deferred.reject();
|
||||
}
|
||||
}
|
||||
);
|
||||
|
||||
return deferred.promise;
|
||||
}
|
||||
|
||||
// Returns a promise which is resolved the first time the given iframe fires
|
||||
// the mozbrowser##eventName event.
|
||||
function expectMozbrowserEvent(iframe, eventName) {
|
||||
|
||||
@ -23,6 +23,7 @@ MOCHITEST_FILES = \
|
||||
test_HighPriorityDowngrade.html \
|
||||
test_HighPriorityDowngrade2.html \
|
||||
test_Background.html \
|
||||
test_BackgroundLRU.html \
|
||||
test_Audio.html \
|
||||
file_Audio.html \
|
||||
silence.ogg \
|
||||
|
||||
@ -0,0 +1,67 @@
|
||||
<!DOCTYPE HTML>
|
||||
<html>
|
||||
<!--
|
||||
Test that calling setVisible('false') on two iframes causes the former one's priority with background LRU to
|
||||
change.
|
||||
-->
|
||||
<head>
|
||||
<script type="application/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
|
||||
<script type="application/javascript" src="../browserElementTestHelpers.js"></script>
|
||||
<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
|
||||
</head>
|
||||
<body>
|
||||
|
||||
<script type="application/javascript;version=1.7">
|
||||
"use strict";
|
||||
|
||||
SimpleTest.waitForExplicitFinish();
|
||||
browserElementTestHelpers.setEnabledPref(true);
|
||||
browserElementTestHelpers.addPermission();
|
||||
browserElementTestHelpers.enableProcessPriorityManager();
|
||||
SpecialPowers.addPermission("embed-apps", true, document);
|
||||
|
||||
function runTest() {
|
||||
var iframe1 = document.createElement('iframe');
|
||||
iframe1.setAttribute('mozbrowser', true);
|
||||
iframe1.src = 'file_MultipleFrames.html';
|
||||
|
||||
var iframe2 = null;
|
||||
var childID = null;
|
||||
|
||||
expectProcessCreated().then(function(chid) {
|
||||
childID = chid;
|
||||
return expectPriorityChange(childID, 'FOREGROUND');
|
||||
}).then(function() {
|
||||
return expectMozbrowserEvent(iframe1, 'openwindow');
|
||||
}).then(function() {
|
||||
var p = expectPriorityChange(childID, 'BACKGROUND');
|
||||
iframe1.setVisible(false);
|
||||
return p;
|
||||
}).then(function() {
|
||||
iframe2 = document.createElement('iframe');
|
||||
iframe2.setAttribute('mozbrowser', true);
|
||||
iframe2.setAttribute('mozapp', 'http://example.org/manifest.webapp');
|
||||
iframe2.src = browserElementTestHelpers.emptyPage1;
|
||||
|
||||
document.body.appendChild(iframe2);
|
||||
|
||||
// At this point, we should have iframe1 in background already.
|
||||
// We wait until another one is set to background, too.
|
||||
// Once there are two in background, the first one (LRU order)
|
||||
// should have 'backgroundLRU' equals 1
|
||||
var p = expectPriorityWithBackgroundLRUSet(childID, '1');
|
||||
iframe2.setVisible(false);
|
||||
document.body.removeChild(iframe2);
|
||||
|
||||
return p;
|
||||
|
||||
}).then(SimpleTest.finish);
|
||||
|
||||
document.body.appendChild(iframe1);
|
||||
}
|
||||
|
||||
addEventListener('testready', runTest);
|
||||
|
||||
</script>
|
||||
</body>
|
||||
</html>
|
||||
@ -126,7 +126,8 @@ public:
|
||||
* This function implements ProcessPriorityManager::SetProcessPriority.
|
||||
*/
|
||||
void SetProcessPriority(ContentParent* aContentParent,
|
||||
ProcessPriority aPriority);
|
||||
ProcessPriority aPriority,
|
||||
uint32_t aBackgroundLRU = 0);
|
||||
|
||||
/**
|
||||
* If a magic testing-only pref is set, notify the observer service on the
|
||||
@ -226,6 +227,7 @@ public:
|
||||
|
||||
int32_t Pid() const;
|
||||
uint64_t ChildID() const;
|
||||
bool IsPreallocated() const;
|
||||
|
||||
/**
|
||||
* Used in logging, this method returns the ContentParent's name followed by
|
||||
@ -260,10 +262,12 @@ public:
|
||||
* This overload is equivalent to SetPriorityNow(aPriority,
|
||||
* ComputeCPUPriority()).
|
||||
*/
|
||||
void SetPriorityNow(ProcessPriority aPriority);
|
||||
void SetPriorityNow(ProcessPriority aPriority,
|
||||
uint32_t aBackgroundLRU = 0);
|
||||
|
||||
void SetPriorityNow(ProcessPriority aPriority,
|
||||
ProcessCPUPriority aCPUPriority);
|
||||
ProcessCPUPriority aCPUPriority,
|
||||
uint32_t aBackgroundLRU = 0);
|
||||
|
||||
void ShutDown();
|
||||
|
||||
@ -291,6 +295,46 @@ private:
|
||||
nsCOMPtr<nsITimer> mResetPriorityTimer;
|
||||
};
|
||||
|
||||
class BackgroundProcessLRUPool MOZ_FINAL
|
||||
{
|
||||
public:
|
||||
static BackgroundProcessLRUPool* Singleton();
|
||||
|
||||
/**
|
||||
* Used to remove a ContentParent from background LRU pool when
|
||||
* it is destroyed or its priority changed from BACKGROUND to others.
|
||||
*/
|
||||
void RemoveFromBackgroundLRUPool(ContentParent* aContentParent);
|
||||
|
||||
/**
|
||||
* Used to add a ContentParent into background LRU pool when
|
||||
* its priority changed to BACKGROUND from others.
|
||||
*/
|
||||
void AddIntoBackgroundLRUPool(ContentParent* aContentParent);
|
||||
|
||||
private:
|
||||
static StaticAutoPtr<BackgroundProcessLRUPool> sSingleton;
|
||||
|
||||
int32_t mLRUPoolLevels;
|
||||
int32_t mLRUPoolSize;
|
||||
int32_t mLRUPoolAvailableIndex;
|
||||
nsTArray<ContentParent*> mLRUPool;
|
||||
|
||||
uint32_t CalculateLRULevel(uint32_t aBackgroundLRUPoolIndex);
|
||||
|
||||
nsresult UpdateAvailableIndexInLRUPool(
|
||||
ContentParent* aContentParent,
|
||||
int32_t aTargetIndex = -1);
|
||||
|
||||
void ShiftLRUPool();
|
||||
|
||||
void EnsureLRUPool();
|
||||
|
||||
BackgroundProcessLRUPool();
|
||||
DISALLOW_EVIL_CONSTRUCTORS(BackgroundProcessLRUPool);
|
||||
|
||||
};
|
||||
|
||||
/* static */ bool ProcessPriorityManagerImpl::sInitialized = false;
|
||||
/* static */ bool ProcessPriorityManagerImpl::sPrefListenersRegistered = false;
|
||||
/* static */ StaticRefPtr<ProcessPriorityManagerImpl>
|
||||
@ -421,12 +465,13 @@ ProcessPriorityManagerImpl::GetParticularProcessPriorityManager(
|
||||
|
||||
void
|
||||
ProcessPriorityManagerImpl::SetProcessPriority(ContentParent* aContentParent,
|
||||
ProcessPriority aPriority)
|
||||
ProcessPriority aPriority,
|
||||
uint32_t aBackgroundLRU)
|
||||
{
|
||||
MOZ_ASSERT(aContentParent);
|
||||
nsRefPtr<ParticularProcessPriorityManager> pppm =
|
||||
GetParticularProcessPriorityManager(aContentParent);
|
||||
pppm->SetPriorityNow(aPriority);
|
||||
pppm->SetPriorityNow(aPriority, aBackgroundLRU);
|
||||
}
|
||||
|
||||
void
|
||||
@ -657,6 +702,12 @@ ParticularProcessPriorityManager::Pid() const
|
||||
return mContentParent ? mContentParent->Pid() : -1;
|
||||
}
|
||||
|
||||
bool
|
||||
ParticularProcessPriorityManager::IsPreallocated() const
|
||||
{
|
||||
return mContentParent ? mContentParent->IsPreallocated() : false;
|
||||
}
|
||||
|
||||
const nsAutoCString&
|
||||
ParticularProcessPriorityManager::NameWithComma()
|
||||
{
|
||||
@ -896,20 +947,35 @@ ParticularProcessPriorityManager::ResetCPUPriorityNow()
|
||||
}
|
||||
|
||||
void
|
||||
ParticularProcessPriorityManager::SetPriorityNow(ProcessPriority aPriority)
|
||||
ParticularProcessPriorityManager::SetPriorityNow(ProcessPriority aPriority,
|
||||
uint32_t aBackgroundLRU)
|
||||
{
|
||||
SetPriorityNow(aPriority, ComputeCPUPriority());
|
||||
SetPriorityNow(aPriority, ComputeCPUPriority(), aBackgroundLRU);
|
||||
}
|
||||
|
||||
void
|
||||
ParticularProcessPriorityManager::SetPriorityNow(ProcessPriority aPriority,
|
||||
ProcessCPUPriority aCPUPriority)
|
||||
ProcessCPUPriority aCPUPriority,
|
||||
uint32_t aBackgroundLRU)
|
||||
{
|
||||
if (aPriority == PROCESS_PRIORITY_UNKNOWN) {
|
||||
MOZ_ASSERT(false);
|
||||
return;
|
||||
}
|
||||
|
||||
if (aBackgroundLRU > 0 &&
|
||||
aPriority == PROCESS_PRIORITY_BACKGROUND &&
|
||||
mPriority == PROCESS_PRIORITY_BACKGROUND) {
|
||||
hal::SetProcessPriority(Pid(), mPriority, mCPUPriority, aBackgroundLRU);
|
||||
|
||||
nsPrintfCString ProcessPriorityWithBackgroundLRU("%s:%d",
|
||||
ProcessPriorityToString(mPriority, mCPUPriority),
|
||||
aBackgroundLRU);
|
||||
|
||||
FireTestOnlyObserverNotification("process-priority-with-background-LRU-set",
|
||||
ProcessPriorityWithBackgroundLRU.get());
|
||||
}
|
||||
|
||||
if (!mContentParent ||
|
||||
!ProcessPriorityManagerImpl::PrefsEnabled() ||
|
||||
(mPriority == aPriority && mCPUPriority == aCPUPriority)) {
|
||||
@ -924,6 +990,18 @@ ParticularProcessPriorityManager::SetPriorityNow(ProcessPriority aPriority,
|
||||
return;
|
||||
}
|
||||
|
||||
if (aPriority == PROCESS_PRIORITY_BACKGROUND &&
|
||||
mPriority != PROCESS_PRIORITY_BACKGROUND &&
|
||||
!IsPreallocated()) {
|
||||
ProcessPriorityManager::AddIntoBackgroundLRUPool(mContentParent);
|
||||
}
|
||||
|
||||
if (aPriority != PROCESS_PRIORITY_BACKGROUND &&
|
||||
mPriority == PROCESS_PRIORITY_BACKGROUND &&
|
||||
!IsPreallocated()) {
|
||||
ProcessPriorityManager::RemoveFromBackgroundLRUPool(mContentParent);
|
||||
}
|
||||
|
||||
LOGP("Changing priority from %s to %s.",
|
||||
ProcessPriorityToString(mPriority, mCPUPriority),
|
||||
ProcessPriorityToString(aPriority, aCPUPriority));
|
||||
@ -944,6 +1022,13 @@ ParticularProcessPriorityManager::SetPriorityNow(ProcessPriority aPriority,
|
||||
unused << mContentParent->SendMinimizeMemoryUsage();
|
||||
}
|
||||
|
||||
nsPrintfCString ProcessPriorityWithBackgroundLRU("%s:%d",
|
||||
ProcessPriorityToString(mPriority, mCPUPriority),
|
||||
aBackgroundLRU);
|
||||
|
||||
FireTestOnlyObserverNotification("process-priority-with-background-LRU-set",
|
||||
ProcessPriorityWithBackgroundLRU.get());
|
||||
|
||||
FireTestOnlyObserverNotification("process-priority-set",
|
||||
ProcessPriorityToString(mPriority, mCPUPriority));
|
||||
|
||||
@ -965,6 +1050,8 @@ ParticularProcessPriorityManager::ShutDown()
|
||||
mResetPriorityTimer = nullptr;
|
||||
}
|
||||
|
||||
ProcessPriorityManager::RemoveFromBackgroundLRUPool(mContentParent);
|
||||
|
||||
mContentParent = nullptr;
|
||||
}
|
||||
|
||||
@ -1098,6 +1185,181 @@ ProcessPriorityManagerChild::CurrentProcessIsForeground()
|
||||
mCachedPriority >= PROCESS_PRIORITY_FOREGROUND;
|
||||
}
|
||||
|
||||
/* static */ StaticAutoPtr<BackgroundProcessLRUPool>
|
||||
BackgroundProcessLRUPool::sSingleton;
|
||||
|
||||
/* static */ BackgroundProcessLRUPool*
|
||||
BackgroundProcessLRUPool::Singleton()
|
||||
{
|
||||
if (!sSingleton) {
|
||||
sSingleton = new BackgroundProcessLRUPool();
|
||||
ClearOnShutdown(&sSingleton);
|
||||
}
|
||||
return sSingleton;
|
||||
}
|
||||
|
||||
BackgroundProcessLRUPool::BackgroundProcessLRUPool()
|
||||
{
|
||||
EnsureLRUPool();
|
||||
}
|
||||
|
||||
uint32_t
|
||||
BackgroundProcessLRUPool::CalculateLRULevel(uint32_t aBackgroundLRUPoolIndex)
|
||||
{
|
||||
// Set LRU level of each background process and maintain LRU buffer as below:
|
||||
|
||||
// Priority background : LRU0
|
||||
// Priority background+1: LRU1, LRU2
|
||||
// Priority background+2: LRU3, LRU4, LRU5, LRU6
|
||||
// Priority background+3: LRU7, LRU8, LRU9, LRU10, LRU11, LRU12, LRU13, LRU14
|
||||
// ...
|
||||
// Priority background+L-1: 2^(number of background LRU pool levels - 1)
|
||||
// (End of buffer)
|
||||
|
||||
return (uint32_t)(log((float)aBackgroundLRUPoolIndex) / log(2.0));
|
||||
}
|
||||
|
||||
void
|
||||
BackgroundProcessLRUPool::EnsureLRUPool()
|
||||
{
|
||||
// We set mBackgroundLRUPoolLevels according to our pref.
|
||||
// This value is used to set background process LRU pool
|
||||
if (!NS_SUCCEEDED(Preferences::GetInt(
|
||||
"dom.ipc.processPriorityManager.backgroundLRUPoolLevels",
|
||||
&mLRUPoolLevels))) {
|
||||
mLRUPoolLevels = 1;
|
||||
}
|
||||
|
||||
if (mLRUPoolLevels <= 0) {
|
||||
MOZ_CRASH();
|
||||
}
|
||||
|
||||
// GonkHal defines OOM_ADJUST_MAX is 15 and b2g.js defines
|
||||
// PROCESS_PRIORITY_BACKGROUND's oom_score_adj is 667 and oom_adj is 10.
|
||||
// This means we can only have at most (15 -10 + 1) = 6 background LRU levels.
|
||||
// See bug 822325 comment 49
|
||||
MOZ_ASSERT(mLRUPoolLevels <= 6);
|
||||
|
||||
// LRU pool size = 2 ^ (number of background LRU pool levels) - 1
|
||||
mLRUPoolSize = (1 << mLRUPoolLevels) - 1;
|
||||
|
||||
mLRUPoolAvailableIndex = 0;
|
||||
|
||||
LOG("Making background LRU pool with size(%d)", mLRUPoolSize);
|
||||
|
||||
mLRUPool.InsertElementsAt(0, mLRUPoolSize, (ContentParent*)nullptr);
|
||||
}
|
||||
|
||||
void
|
||||
BackgroundProcessLRUPool::RemoveFromBackgroundLRUPool(
|
||||
ContentParent* aContentParent)
|
||||
{
|
||||
for (int32_t i = 0; i < mLRUPoolSize; i++) {
|
||||
if (mLRUPool[i]) {
|
||||
if (mLRUPool[i]->ChildID() == aContentParent->ChildID()) {
|
||||
|
||||
mLRUPool[i] = nullptr;
|
||||
LOG("Remove ChildID(%llu) from LRU pool", aContentParent->ChildID());
|
||||
|
||||
// After we remove this ContentParent from LRU pool, we still need to
|
||||
// update the available index if the index of removed one is less than
|
||||
// the available index we already have.
|
||||
UpdateAvailableIndexInLRUPool(aContentParent, i);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
nsresult
|
||||
BackgroundProcessLRUPool::UpdateAvailableIndexInLRUPool(
|
||||
ContentParent* aContentParent,
|
||||
int32_t aTargetIndex)
|
||||
{
|
||||
// If we specify which index we want to assign to mLRUPoolAvailableIndex,
|
||||
// We have to make sure the index in LRUPool doesn't point to any
|
||||
// ContentParent.
|
||||
if (aTargetIndex >= 0 && aTargetIndex < mLRUPoolSize &&
|
||||
aTargetIndex < mLRUPoolAvailableIndex &&
|
||||
!mLRUPool[aTargetIndex]) {
|
||||
mLRUPoolAvailableIndex = aTargetIndex;
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
// When we didn't specify any legal aTargetIndex, then we just check
|
||||
// whether current mLRUPoolAvailableIndex points to any ContentParent or not.
|
||||
if (mLRUPoolAvailableIndex >= 0 && mLRUPoolAvailableIndex < mLRUPoolSize &&
|
||||
!(mLRUPool[mLRUPoolAvailableIndex])) {
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
// Both above way failed. So now we have to find proper value
|
||||
// for mLRUPoolAvailableIndex.
|
||||
// We are looking for an available index. We only shift process with
|
||||
// LRU less than the available index should have, so we stop update
|
||||
// mLRUPoolAvailableIndex from the for loop once we got a candidate.
|
||||
mLRUPoolAvailableIndex = -1;
|
||||
|
||||
for (int32_t i = 0; i < mLRUPoolSize; i++) {
|
||||
if (mLRUPool[i]) {
|
||||
if (mLRUPool[i]->ChildID() == aContentParent->ChildID()) {
|
||||
LOG("ChildID(%llu) already in LRU pool", aContentParent->ChildID());
|
||||
MOZ_ASSERT(false);
|
||||
return NS_ERROR_UNEXPECTED;
|
||||
}
|
||||
continue;
|
||||
} else {
|
||||
if (mLRUPoolAvailableIndex == -1) {
|
||||
mLRUPoolAvailableIndex = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// If the LRUPool is already full, mLRUPoolAvailableIndex is still -1 after
|
||||
// above loop finished. We should set mLRUPoolAvailableIndex
|
||||
// to mLRUPoolSize - 1 in this case. Here uses the mod operator to do it:
|
||||
// New mLRUPoolAvailableIndex either equals old mLRUPoolAvailableIndex, or
|
||||
// mLRUPoolSize - 1 if old mLRUPoolAvailableIndex is -1.
|
||||
mLRUPoolAvailableIndex =
|
||||
(mLRUPoolAvailableIndex + mLRUPoolSize) % mLRUPoolSize;
|
||||
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
void
|
||||
BackgroundProcessLRUPool::ShiftLRUPool()
|
||||
{
|
||||
for (int32_t i = mLRUPoolAvailableIndex; i > 0; i--) {
|
||||
mLRUPool[i] = mLRUPool[i - 1];
|
||||
// Check whether i+1 is power of Two.
|
||||
// If so, then it crossed a LRU group boundary and
|
||||
// we need to assign its new process priority LRU.
|
||||
if (!((i + 1) & i)) {
|
||||
ProcessPriorityManagerImpl::GetSingleton()->SetProcessPriority(
|
||||
mLRUPool[i], PROCESS_PRIORITY_BACKGROUND, CalculateLRULevel(i + 1));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
BackgroundProcessLRUPool::AddIntoBackgroundLRUPool(
|
||||
ContentParent* aContentParent)
|
||||
{
|
||||
// We have to make sure that we have correct available index in LRU pool
|
||||
if (!NS_SUCCEEDED(
|
||||
UpdateAvailableIndexInLRUPool(aContentParent))) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Shift the list in the pool, so we have room at index 0 for the newly added
|
||||
// ContentParent
|
||||
ShiftLRUPool();
|
||||
|
||||
mLRUPool[0] = aContentParent;
|
||||
|
||||
LOG("Add ChildID(%llu) into LRU pool", aContentParent->ChildID());
|
||||
}
|
||||
|
||||
} // anonymous namespace
|
||||
|
||||
namespace mozilla {
|
||||
@ -1122,6 +1384,31 @@ ProcessPriorityManager::SetProcessPriority(ContentParent* aContentParent,
|
||||
}
|
||||
}
|
||||
|
||||
/* static */ void
|
||||
ProcessPriorityManager::RemoveFromBackgroundLRUPool(
|
||||
ContentParent* aContentParent)
|
||||
{
|
||||
MOZ_ASSERT(aContentParent);
|
||||
|
||||
BackgroundProcessLRUPool* singleton =
|
||||
BackgroundProcessLRUPool::Singleton();
|
||||
if (singleton) {
|
||||
singleton->RemoveFromBackgroundLRUPool(aContentParent);
|
||||
}
|
||||
}
|
||||
|
||||
/* static */ void
|
||||
ProcessPriorityManager::AddIntoBackgroundLRUPool(ContentParent* aContentParent)
|
||||
{
|
||||
MOZ_ASSERT(aContentParent);
|
||||
|
||||
BackgroundProcessLRUPool* singleton =
|
||||
BackgroundProcessLRUPool::Singleton();
|
||||
if (singleton) {
|
||||
singleton->AddIntoBackgroundLRUPool(aContentParent);
|
||||
}
|
||||
}
|
||||
|
||||
/* static */ bool
|
||||
ProcessPriorityManager::CurrentProcessIsForeground()
|
||||
{
|
||||
|
||||
@ -68,6 +68,18 @@ public:
|
||||
*/
|
||||
static bool CurrentProcessIsForeground();
|
||||
|
||||
/**
|
||||
* Used to remove a ContentParent from background LRU pool when
|
||||
* it is destroyed or its priority changed from BACKGROUND to others.
|
||||
*/
|
||||
static void RemoveFromBackgroundLRUPool(dom::ContentParent* aContentParent);
|
||||
|
||||
/**
|
||||
* Used to add a ContentParent into background LRU pool when
|
||||
* its priority changed to BACKGROUND from others.
|
||||
*/
|
||||
static void AddIntoBackgroundLRUPool(dom::ContentParent* aContentParent);
|
||||
|
||||
private:
|
||||
ProcessPriorityManager();
|
||||
DISALLOW_EVIL_CONSTRUCTORS(ProcessPriorityManager);
|
||||
|
||||
@ -850,11 +850,14 @@ SetAlarm(int32_t aSeconds, int32_t aNanoseconds)
|
||||
void
|
||||
SetProcessPriority(int aPid,
|
||||
ProcessPriority aPriority,
|
||||
ProcessCPUPriority aCPUPriority)
|
||||
ProcessCPUPriority aCPUPriority,
|
||||
uint32_t aBackgroundLRU)
|
||||
{
|
||||
// n.b. The sandboxed implementation crashes; SetProcessPriority works only
|
||||
// from the main process.
|
||||
PROXY_IF_SANDBOXED(SetProcessPriority(aPid, aPriority, aCPUPriority));
|
||||
MOZ_ASSERT(aBackgroundLRU == 0 || aPriority == PROCESS_PRIORITY_BACKGROUND);
|
||||
PROXY_IF_SANDBOXED(SetProcessPriority(aPid, aPriority, aCPUPriority,
|
||||
aBackgroundLRU));
|
||||
}
|
||||
|
||||
// From HalTypes.h.
|
||||
|
||||
@ -483,7 +483,8 @@ bool SetAlarm(int32_t aSeconds, int32_t aNanoseconds);
|
||||
*/
|
||||
void SetProcessPriority(int aPid,
|
||||
hal::ProcessPriority aPriority,
|
||||
hal::ProcessCPUPriority aCPUPriority);
|
||||
hal::ProcessCPUPriority aCPUPriority,
|
||||
uint32_t aLRU = 0);
|
||||
|
||||
/**
|
||||
* Register an observer for the FM radio.
|
||||
|
||||
@ -12,10 +12,12 @@ namespace hal_impl {
|
||||
void
|
||||
SetProcessPriority(int aPid,
|
||||
ProcessPriority aPriority,
|
||||
ProcessCPUPriority aCPUPriority)
|
||||
ProcessCPUPriority aCPUPriority,
|
||||
uint32_t aBackgroundLRU)
|
||||
{
|
||||
HAL_LOG(("FallbackProcessPriority - SetProcessPriority(%d, %s)\n",
|
||||
aPid, ProcessPriorityToString(aPriority, aCPUPriority)));
|
||||
HAL_LOG(("FallbackProcessPriority - SetProcessPriority(%d, %s, %u)\n",
|
||||
aPid, ProcessPriorityToString(aPriority, aCPUPriority),
|
||||
aBackgroundLRU));
|
||||
}
|
||||
|
||||
} // hal_impl
|
||||
|
||||
@ -1029,6 +1029,15 @@ OomAdjOfOomScoreAdj(int aOomScoreAdj)
|
||||
return adj;
|
||||
}
|
||||
|
||||
static void
|
||||
RoundOomScoreAdjUpWithBackroundLRU(int& aOomScoreAdj, uint32_t aBackgroundLRU)
|
||||
{
|
||||
// We want to add minimum value to round OomScoreAdj up according to
|
||||
// the steps by aBackgroundLRU.
|
||||
aOomScoreAdj +=
|
||||
ceil(((float)OOM_SCORE_ADJ_MAX / OOM_ADJUST_MAX) * aBackgroundLRU);
|
||||
}
|
||||
|
||||
static void
|
||||
EnsureKernelLowMemKillerParamsSet()
|
||||
{
|
||||
@ -1204,10 +1213,11 @@ SetNiceForPid(int aPid, int aNice)
|
||||
void
|
||||
SetProcessPriority(int aPid,
|
||||
ProcessPriority aPriority,
|
||||
ProcessCPUPriority aCPUPriority)
|
||||
ProcessCPUPriority aCPUPriority,
|
||||
uint32_t aBackgroundLRU)
|
||||
{
|
||||
HAL_LOG(("SetProcessPriority(pid=%d, priority=%d, cpuPriority=%d)",
|
||||
aPid, aPriority, aCPUPriority));
|
||||
HAL_LOG(("SetProcessPriority(pid=%d, priority=%d, cpuPriority=%d, LRU=%u)",
|
||||
aPid, aPriority, aCPUPriority, aBackgroundLRU));
|
||||
|
||||
// If this is the first time SetProcessPriority was called, set the kernel's
|
||||
// OOM parameters according to our prefs.
|
||||
@ -1223,6 +1233,8 @@ SetProcessPriority(int aPid,
|
||||
"hal.processPriorityManager.gonk.%s.OomScoreAdjust",
|
||||
ProcessPriorityToString(aPriority)).get(), &oomScoreAdj);
|
||||
|
||||
RoundOomScoreAdjUpWithBackroundLRU(oomScoreAdj, aBackgroundLRU);
|
||||
|
||||
if (NS_SUCCEEDED(rv)) {
|
||||
int clampedOomScoreAdj = clamped<int>(oomScoreAdj, OOM_SCORE_ADJ_MIN,
|
||||
OOM_SCORE_ADJ_MAX);
|
||||
|
||||
@ -342,7 +342,8 @@ SetAlarm(int32_t aSeconds, int32_t aNanoseconds)
|
||||
void
|
||||
SetProcessPriority(int aPid,
|
||||
ProcessPriority aPriority,
|
||||
ProcessCPUPriority aCPUPriority)
|
||||
ProcessCPUPriority aCPUPriority,
|
||||
uint32_t aBackgroundLRU)
|
||||
{
|
||||
NS_RUNTIMEABORT("Only the main process may set processes' priorities.");
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user