Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2025-04-04 13:42:48 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Alan Huang 2013-10-01 11:54:59 +08:00
parent 4975798735
commit f36c0848bb
11 changed files with 441 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
b2g/app/b2g.js
View File

@ -603,6 +603,11 @@ pref("dom.ipc.processPriorityManager.enabled", true);
pref("dom.ipc.processPriorityManager.backgroundGracePeriodMS", 1000); pref("dom.ipc.processPriorityManager.backgroundGracePeriodMS", 1000);
pref("dom.ipc.processPriorityManager.temporaryPriorityLockMS", 5000); 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 // Kernel parameters for process priorities. These affect how processes are
// killed on low-memory and their relative CPU priorities. // killed on low-memory and their relative CPU priorities.
// //

32
dom/browser-element/mochitest/browserElementTestHelpers.js
View File

@ -46,6 +46,7 @@ const browserElementTestHelpers = {
enableProcessPriorityManager: function() { enableProcessPriorityManager: function() {
this._setPref('dom.ipc.processPriorityManager.testMode', true); this._setPref('dom.ipc.processPriorityManager.testMode', true);
this._setPref('dom.ipc.processPriorityManager.enabled', true); this._setPref('dom.ipc.processPriorityManager.enabled', true);
this._setPref('dom.ipc.processPriorityManager.backgroundLRUPoolLevels', 2);
}, },
setEnabledPref: function(value) { setEnabledPref: function(value) {
@ -193,6 +194,37 @@ function expectPriorityChange(childID, expectedPriority,
return deferred.promise; 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 // Returns a promise which is resolved the first time the given iframe fires
// the mozbrowser##eventName event. // the mozbrowser##eventName event.
function expectMozbrowserEvent(iframe, eventName) { function expectMozbrowserEvent(iframe, eventName) {

1
dom/browser-element/mochitest/priority/Makefile.in
View File

@ -23,6 +23,7 @@ MOCHITEST_FILES = \
test_HighPriorityDowngrade.html \ test_HighPriorityDowngrade.html \
test_HighPriorityDowngrade2.html \ test_HighPriorityDowngrade2.html \
test_Background.html \ test_Background.html \
test_BackgroundLRU.html \
test_Audio.html \ test_Audio.html \
file_Audio.html \ file_Audio.html \
silence.ogg \ silence.ogg \

67
dom/browser-element/mochitest/priority/test_BackgroundLRU.html Normal file
View File

@ -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>

303
dom/ipc/ProcessPriorityManager.cpp
View File

@ -126,7 +126,8 @@ public:
* This function implements ProcessPriorityManager::SetProcessPriority. * This function implements ProcessPriorityManager::SetProcessPriority.
*/ */
void SetProcessPriority(ContentParent* aContentParent, 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 * If a magic testing-only pref is set, notify the observer service on the
@ -226,6 +227,7 @@ public:
int32_t Pid() const; int32_t Pid() const;
uint64_t ChildID() const; uint64_t ChildID() const;
bool IsPreallocated() const;
/** /**
* Used in logging, this method returns the ContentParent's name followed by * Used in logging, this method returns the ContentParent's name followed by
@ -260,10 +262,12 @@ public:
* This overload is equivalent to SetPriorityNow(aPriority, * This overload is equivalent to SetPriorityNow(aPriority,
* ComputeCPUPriority()). * ComputeCPUPriority()).
*/ */
void SetPriorityNow(ProcessPriority aPriority); void SetPriorityNow(ProcessPriority aPriority,
uint32_t aBackgroundLRU = 0);
void SetPriorityNow(ProcessPriority aPriority, void SetPriorityNow(ProcessPriority aPriority,
ProcessCPUPriority aCPUPriority); ProcessCPUPriority aCPUPriority,
uint32_t aBackgroundLRU = 0);
void ShutDown(); void ShutDown();
@ -291,6 +295,46 @@ private:
nsCOMPtr<nsITimer> mResetPriorityTimer; 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::sInitialized = false;
/* static */ bool ProcessPriorityManagerImpl::sPrefListenersRegistered = false; /* static */ bool ProcessPriorityManagerImpl::sPrefListenersRegistered = false;
/* static */ StaticRefPtr<ProcessPriorityManagerImpl> /* static */ StaticRefPtr<ProcessPriorityManagerImpl>
@ -421,12 +465,13 @@ ProcessPriorityManagerImpl::GetParticularProcessPriorityManager(
void void
ProcessPriorityManagerImpl::SetProcessPriority(ContentParent* aContentParent, ProcessPriorityManagerImpl::SetProcessPriority(ContentParent* aContentParent,
ProcessPriority aPriority) ProcessPriority aPriority,
uint32_t aBackgroundLRU)
{ {
MOZ_ASSERT(aContentParent); MOZ_ASSERT(aContentParent);
nsRefPtr<ParticularProcessPriorityManager> pppm = nsRefPtr<ParticularProcessPriorityManager> pppm =
GetParticularProcessPriorityManager(aContentParent); GetParticularProcessPriorityManager(aContentParent);
pppm->SetPriorityNow(aPriority); pppm->SetPriorityNow(aPriority, aBackgroundLRU);
} }
void void
@ -657,6 +702,12 @@ ParticularProcessPriorityManager::Pid() const
return mContentParent ? mContentParent->Pid() : -1; return mContentParent ? mContentParent->Pid() : -1;
} }
bool
ParticularProcessPriorityManager::IsPreallocated() const
{
return mContentParent ? mContentParent->IsPreallocated() : false;
}
const nsAutoCString& const nsAutoCString&
ParticularProcessPriorityManager::NameWithComma() ParticularProcessPriorityManager::NameWithComma()
{ {
@ -896,20 +947,35 @@ ParticularProcessPriorityManager::ResetCPUPriorityNow()
} }
void void
ParticularProcessPriorityManager::SetPriorityNow(ProcessPriority aPriority) ParticularProcessPriorityManager::SetPriorityNow(ProcessPriority aPriority,
uint32_t aBackgroundLRU)
{ {
SetPriorityNow(aPriority, ComputeCPUPriority()); SetPriorityNow(aPriority, ComputeCPUPriority(), aBackgroundLRU);
} }
void void
ParticularProcessPriorityManager::SetPriorityNow(ProcessPriority aPriority, ParticularProcessPriorityManager::SetPriorityNow(ProcessPriority aPriority,
ProcessCPUPriority aCPUPriority) ProcessCPUPriority aCPUPriority,
uint32_t aBackgroundLRU)
{ {
if (aPriority == PROCESS_PRIORITY_UNKNOWN) { if (aPriority == PROCESS_PRIORITY_UNKNOWN) {
MOZ_ASSERT(false); MOZ_ASSERT(false);
return; 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 || if (!mContentParent ||
!ProcessPriorityManagerImpl::PrefsEnabled() || !ProcessPriorityManagerImpl::PrefsEnabled() ||
(mPriority == aPriority && mCPUPriority == aCPUPriority)) { (mPriority == aPriority && mCPUPriority == aCPUPriority)) {
@ -924,6 +990,18 @@ ParticularProcessPriorityManager::SetPriorityNow(ProcessPriority aPriority,
return; 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.", LOGP("Changing priority from %s to %s.",
ProcessPriorityToString(mPriority, mCPUPriority), ProcessPriorityToString(mPriority, mCPUPriority),
ProcessPriorityToString(aPriority, aCPUPriority)); ProcessPriorityToString(aPriority, aCPUPriority));
@ -944,6 +1022,13 @@ ParticularProcessPriorityManager::SetPriorityNow(ProcessPriority aPriority,
unused << mContentParent->SendMinimizeMemoryUsage(); unused << mContentParent->SendMinimizeMemoryUsage();
} }
nsPrintfCString ProcessPriorityWithBackgroundLRU("%s:%d",
ProcessPriorityToString(mPriority, mCPUPriority),
aBackgroundLRU);
FireTestOnlyObserverNotification("process-priority-with-background-LRU-set",
ProcessPriorityWithBackgroundLRU.get());
FireTestOnlyObserverNotification("process-priority-set", FireTestOnlyObserverNotification("process-priority-set",
ProcessPriorityToString(mPriority, mCPUPriority)); ProcessPriorityToString(mPriority, mCPUPriority));
@ -965,6 +1050,8 @@ ParticularProcessPriorityManager::ShutDown()
mResetPriorityTimer = nullptr; mResetPriorityTimer = nullptr;
} }
ProcessPriorityManager::RemoveFromBackgroundLRUPool(mContentParent);
mContentParent = nullptr; mContentParent = nullptr;
} }
@ -1098,6 +1185,181 @@ ProcessPriorityManagerChild::CurrentProcessIsForeground()
mCachedPriority >= PROCESS_PRIORITY_FOREGROUND; 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 } // anonymous namespace
namespace mozilla { 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 /* static */ bool
ProcessPriorityManager::CurrentProcessIsForeground() ProcessPriorityManager::CurrentProcessIsForeground()
{ {

12
dom/ipc/ProcessPriorityManager.h
View File

@ -68,6 +68,18 @@ public:
*/ */
static bool CurrentProcessIsForeground(); 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: private:
ProcessPriorityManager(); ProcessPriorityManager();
DISALLOW_EVIL_CONSTRUCTORS(ProcessPriorityManager); DISALLOW_EVIL_CONSTRUCTORS(ProcessPriorityManager);

7
hal/Hal.cpp
View File

@ -850,11 +850,14 @@ SetAlarm(int32_t aSeconds, int32_t aNanoseconds)
void void
SetProcessPriority(int aPid, SetProcessPriority(int aPid,
ProcessPriority aPriority, ProcessPriority aPriority,
ProcessCPUPriority aCPUPriority) ProcessCPUPriority aCPUPriority,
uint32_t aBackgroundLRU)
{ {
// n.b. The sandboxed implementation crashes; SetProcessPriority works only // n.b. The sandboxed implementation crashes; SetProcessPriority works only
// from the main process. // 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. // From HalTypes.h.

3
hal/Hal.h
View File

@ -483,7 +483,8 @@ bool SetAlarm(int32_t aSeconds, int32_t aNanoseconds);
*/ */
void SetProcessPriority(int aPid, void SetProcessPriority(int aPid,
hal::ProcessPriority aPriority, hal::ProcessPriority aPriority,
hal::ProcessCPUPriority aCPUPriority); hal::ProcessCPUPriority aCPUPriority,
uint32_t aLRU = 0);
/** /**
* Register an observer for the FM radio. * Register an observer for the FM radio.

8
hal/fallback/FallbackProcessPriority.cpp
View File

@ -12,10 +12,12 @@ namespace hal_impl {
void void
SetProcessPriority(int aPid, SetProcessPriority(int aPid,
ProcessPriority aPriority, ProcessPriority aPriority,
ProcessCPUPriority aCPUPriority) ProcessCPUPriority aCPUPriority,
uint32_t aBackgroundLRU)
{ {
HAL_LOG(("FallbackProcessPriority - SetProcessPriority(%d, %s)\n", HAL_LOG(("FallbackProcessPriority - SetProcessPriority(%d, %s, %u)\n",
aPid, ProcessPriorityToString(aPriority, aCPUPriority))); aPid, ProcessPriorityToString(aPriority, aCPUPriority),
aBackgroundLRU));
} }
} // hal_impl } // hal_impl

18
hal/gonk/GonkHal.cpp
View File

@ -1029,6 +1029,15 @@ OomAdjOfOomScoreAdj(int aOomScoreAdj)
return adj; 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 static void
EnsureKernelLowMemKillerParamsSet() EnsureKernelLowMemKillerParamsSet()
{ {
@ -1204,10 +1213,11 @@ SetNiceForPid(int aPid, int aNice)
void void
SetProcessPriority(int aPid, SetProcessPriority(int aPid,
ProcessPriority aPriority, ProcessPriority aPriority,
ProcessCPUPriority aCPUPriority) ProcessCPUPriority aCPUPriority,
uint32_t aBackgroundLRU)
{ {
HAL_LOG(("SetProcessPriority(pid=%d, priority=%d, cpuPriority=%d)", HAL_LOG(("SetProcessPriority(pid=%d, priority=%d, cpuPriority=%d, LRU=%u)",
aPid, aPriority, aCPUPriority)); aPid, aPriority, aCPUPriority, aBackgroundLRU));
// If this is the first time SetProcessPriority was called, set the kernel's // If this is the first time SetProcessPriority was called, set the kernel's
// OOM parameters according to our prefs. // OOM parameters according to our prefs.
@ -1223,6 +1233,8 @@ SetProcessPriority(int aPid,
"hal.processPriorityManager.gonk.%s.OomScoreAdjust", "hal.processPriorityManager.gonk.%s.OomScoreAdjust",
ProcessPriorityToString(aPriority)).get(), &oomScoreAdj); ProcessPriorityToString(aPriority)).get(), &oomScoreAdj);
RoundOomScoreAdjUpWithBackroundLRU(oomScoreAdj, aBackgroundLRU);
if (NS_SUCCEEDED(rv)) { if (NS_SUCCEEDED(rv)) {
int clampedOomScoreAdj = clamped<int>(oomScoreAdj, OOM_SCORE_ADJ_MIN, int clampedOomScoreAdj = clamped<int>(oomScoreAdj, OOM_SCORE_ADJ_MIN,
OOM_SCORE_ADJ_MAX); OOM_SCORE_ADJ_MAX);

3
hal/sandbox/SandboxHal.cpp
View File

@ -342,7 +342,8 @@ SetAlarm(int32_t aSeconds, int32_t aNanoseconds)
void void
SetProcessPriority(int aPid, SetProcessPriority(int aPid,
ProcessPriority aPriority, ProcessPriority aPriority,
ProcessCPUPriority aCPUPriority) ProcessCPUPriority aCPUPriority,
uint32_t aBackgroundLRU)
{ {
NS_RUNTIMEABORT("Only the main process may set processes' priorities."); NS_RUNTIMEABORT("Only the main process may set processes' priorities.");
} }