mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/dom/ipc/ProcessPriorityManager.cpp

1526 строки
43 KiB
C++
Исходник Ответственный История

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set sw=2 ts=8 et ft=cpp : */
/* 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 "ProcessPriorityManager.h"
#include "mozilla/ClearOnShutdown.h"
#include "mozilla/dom/ContentParent.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/TabParent.h"
#include "mozilla/Hal.h"
#include "mozilla/Preferences.h"
#include "mozilla/Services.h"
#include "mozilla/unused.h"
#include "AudioChannelService.h"
#include "prlog.h"
#include "nsPrintfCString.h"
#include "nsXULAppAPI.h"
#include "nsIFrameLoader.h"
#include "nsIObserverService.h"
#include "StaticPtr.h"
#include "nsIMozBrowserFrame.h"
#include "nsIObserver.h"
#include "nsITimer.h"
#include "nsIPropertyBag2.h"
#include "nsComponentManagerUtils.h"
#ifdef XP_WIN
#include <process.h>
#define getpid _getpid
#else
#include <unistd.h>
#endif
#ifdef LOG
#undef LOG
#endif
// Use LOGP inside a ParticularProcessPriorityManager method; use LOG
// everywhere else. LOGP prints out information about the particular process
// priority manager.
//
// (Wow, our logging story is a huge mess.)
// #define ENABLE_LOGGING 1
#if defined(ANDROID) && defined(ENABLE_LOGGING)
# include <android/log.h>
# define LOG(fmt, ...) \
__android_log_print(ANDROID_LOG_INFO, \
"Gecko:ProcessPriorityManager", \
fmt, ## __VA_ARGS__)
# define LOGP(fmt, ...) \
__android_log_print(ANDROID_LOG_INFO, \
"Gecko:ProcessPriorityManager", \
"[%schild-id=%llu, pid=%d] " fmt, \
NameWithComma().get(), \
(long long unsigned) ChildID(), Pid(), ## __VA_ARGS__)
#elif defined(ENABLE_LOGGING)
# define LOG(fmt, ...) \
printf("ProcessPriorityManager - " fmt "\n", ##__VA_ARGS__)
# define LOGP(fmt, ...) \
printf("ProcessPriorityManager[%schild-id=%llu, pid=%d] - " fmt "\n", \
NameWithComma().get(), \
(unsigned long long) ChildID(), Pid(), ##__VA_ARGS__)
#elif defined(PR_LOGGING)
static PRLogModuleInfo*
GetPPMLog()
{
static PRLogModuleInfo *sLog;
if (!sLog)
sLog = PR_NewLogModule("ProcessPriorityManager");
return sLog;
}
# define LOG(fmt, ...) \
PR_LOG(GetPPMLog(), PR_LOG_DEBUG, \
("ProcessPriorityManager - " fmt, ##__VA_ARGS__))
# define LOGP(fmt, ...) \
PR_LOG(GetPPMLog(), PR_LOG_DEBUG, \
("ProcessPriorityManager[%schild-id=%llu, pid=%d] - " fmt, \
NameWithComma().get(), \
(unsigned long long) ChildID(), Pid(), ##__VA_ARGS__))
#else
#define LOG(fmt, ...)
#define LOGP(fmt, ...)
#endif
using namespace mozilla;
using namespace mozilla::dom;
using namespace mozilla::hal;
namespace {
class ParticularProcessPriorityManager;
/**
* This singleton class does the work to implement the process priority manager
* in the main process. This class may not be used in child processes. (You
* can call StaticInit, but it won't do anything, and GetSingleton() will
* return null.)
*
* ProcessPriorityManager::CurrentProcessIsForeground() and
* ProcessPriorityManager::AnyProcessHasHighPriority() which can be called in
* any process, are handled separately, by the ProcessPriorityManagerChild
* class.
*/
class ProcessPriorityManagerImpl MOZ_FINAL
: public nsIObserver
, public WakeLockObserver
{
public:
/**
* If we're in the main process, get the ProcessPriorityManagerImpl
* singleton. If we're in a child process, return null.
*/
static ProcessPriorityManagerImpl* GetSingleton();
static void StaticInit();
static bool PrefsEnabled();
NS_DECL_ISUPPORTS
NS_DECL_NSIOBSERVER
/**
* This function implements ProcessPriorityManager::SetProcessPriority.
*/
void SetProcessPriority(ContentParent* aContentParent,
ProcessPriority aPriority,
uint32_t aBackgroundLRU = 0);
/**
* If a magic testing-only pref is set, notify the observer service on the
* given topic with the given data. This is used for testing
*/
void FireTestOnlyObserverNotification(const char* aTopic,
const nsACString& aData = EmptyCString());
/**
* Does some process, other than the one handled by aParticularManager, have
* priority FOREGROUND_HIGH?
*/
bool OtherProcessHasHighPriority(
ParticularProcessPriorityManager* aParticularManager);
/**
* Does one of the child processes have priority FOREGROUND_HIGH?
*/
bool ChildProcessHasHighPriority();
/**
* This must be called by a ParticularProcessPriorityManager when it changes
* its priority.
*/
void NotifyProcessPriorityChanged(
ParticularProcessPriorityManager* aParticularManager,
hal::ProcessPriority aOldPriority);
/**
* Implements WakeLockObserver, used to monitor wake lock changes in the
* main process.
*/
virtual void Notify(const WakeLockInformation& aInfo) MOZ_OVERRIDE;
private:
static bool sPrefListenersRegistered;
static bool sInitialized;
static StaticRefPtr<ProcessPriorityManagerImpl> sSingleton;
static void PrefChangedCallback(const char* aPref, void* aClosure);
ProcessPriorityManagerImpl();
~ProcessPriorityManagerImpl();
DISALLOW_EVIL_CONSTRUCTORS(ProcessPriorityManagerImpl);
void Init();
already_AddRefed<ParticularProcessPriorityManager>
GetParticularProcessPriorityManager(ContentParent* aContentParent);
void ObserveContentParentCreated(nsISupports* aContentParent);
void ObserveContentParentDestroyed(nsISupports* aSubject);
void ResetAllCPUPriorities();
nsDataHashtable<nsUint64HashKey, nsRefPtr<ParticularProcessPriorityManager> >
mParticularManagers;
bool mHighPriority;
nsTHashtable<nsUint64HashKey> mHighPriorityChildIDs;
};
/**
* This singleton class implements the parts of the process priority manager
* that are available from all processes.
*/
class ProcessPriorityManagerChild MOZ_FINAL
: public nsIObserver
{
public:
static void StaticInit();
static ProcessPriorityManagerChild* Singleton();
NS_DECL_ISUPPORTS
NS_DECL_NSIOBSERVER
bool CurrentProcessIsForeground();
bool CurrentProcessIsHighPriority();
private:
static StaticRefPtr<ProcessPriorityManagerChild> sSingleton;
ProcessPriorityManagerChild();
~ProcessPriorityManagerChild() {}
DISALLOW_EVIL_CONSTRUCTORS(ProcessPriorityManagerChild);
void Init();
hal::ProcessPriority mCachedPriority;
};
/**
* This class manages the priority of one particular process. It is
* main-process only.
*/
class ParticularProcessPriorityManager MOZ_FINAL
: public WakeLockObserver
, public nsIObserver
, public nsITimerCallback
, public nsSupportsWeakReference
{
~ParticularProcessPriorityManager();
public:
explicit ParticularProcessPriorityManager(ContentParent* aContentParent);
NS_DECL_ISUPPORTS
NS_DECL_NSIOBSERVER
NS_DECL_NSITIMERCALLBACK
virtual void Notify(const WakeLockInformation& aInfo) MOZ_OVERRIDE;
void Init();
int32_t Pid() const;
uint64_t ChildID() const;
bool IsPreallocated() const;
/**
* Used in logging, this method returns the ContentParent's name followed by
* ", ". If we can't get the ContentParent's name for some reason, it
* returns an empty string.
*
* The reference returned here is guaranteed to be live until the next call
* to NameWithComma() or until the ParticularProcessPriorityManager is
* destroyed, whichever comes first.
*/
const nsAutoCString& NameWithComma();
bool HasAppType(const char* aAppType);
bool IsExpectingSystemMessage();
void OnAudioChannelProcessChanged(nsISupports* aSubject);
void OnRemoteBrowserFrameShown(nsISupports* aSubject);
void OnTabParentDestroyed(nsISupports* aSubject);
void OnFrameloaderVisibleChanged(nsISupports* aSubject);
void OnChannelConnected(nsISupports* aSubject);
ProcessPriority CurrentPriority();
ProcessPriority ComputePriority();
ProcessCPUPriority ComputeCPUPriority(ProcessPriority aPriority);
void ScheduleResetPriority(const char* aTimeoutPref);
void ResetPriority();
void ResetPriorityNow();
void ResetCPUPriorityNow();
/**
* This overload is equivalent to SetPriorityNow(aPriority,
* ComputeCPUPriority()).
*/
void SetPriorityNow(ProcessPriority aPriority,
uint32_t aBackgroundLRU = 0);
void SetPriorityNow(ProcessPriority aPriority,
ProcessCPUPriority aCPUPriority,
uint32_t aBackgroundLRU = 0);
void ShutDown();
private:
void FireTestOnlyObserverNotification(
const char* aTopic,
const nsACString& aData = EmptyCString());
void FireTestOnlyObserverNotification(
const char* aTopic,
const char* aData = nullptr);
ContentParent* mContentParent;
uint64_t mChildID;
ProcessPriority mPriority;
ProcessCPUPriority mCPUPriority;
bool mHoldsCPUWakeLock;
bool mHoldsHighPriorityWakeLock;
/**
* Used to implement NameWithComma().
*/
nsAutoCString mNameWithComma;
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>
ProcessPriorityManagerImpl::sSingleton;
NS_IMPL_ISUPPORTS(ProcessPriorityManagerImpl,
nsIObserver);
/* static */ void
ProcessPriorityManagerImpl::PrefChangedCallback(const char* aPref,
void* aClosure)
{
StaticInit();
}
/* static */ bool
ProcessPriorityManagerImpl::PrefsEnabled()
{
return Preferences::GetBool("dom.ipc.processPriorityManager.enabled") &&
!Preferences::GetBool("dom.ipc.tabs.disabled");
}
/* static */ void
ProcessPriorityManagerImpl::StaticInit()
{
if (sInitialized) {
return;
}
// The process priority manager is main-process only.
if (XRE_GetProcessType() != GeckoProcessType_Default) {
sInitialized = true;
return;
}
// If IPC tabs aren't enabled at startup, don't bother with any of this.
if (!PrefsEnabled()) {
LOG("InitProcessPriorityManager bailing due to prefs.");
// Run StaticInit() again if the prefs change. We don't expect this to
// happen in normal operation, but it happens during testing.
if (!sPrefListenersRegistered) {
sPrefListenersRegistered = true;
Preferences::RegisterCallback(PrefChangedCallback,
"dom.ipc.processPriorityManager.enabled");
Preferences::RegisterCallback(PrefChangedCallback,
"dom.ipc.tabs.disabled");
}
return;
}
sInitialized = true;
sSingleton = new ProcessPriorityManagerImpl();
sSingleton->Init();
ClearOnShutdown(&sSingleton);
}
/* static */ ProcessPriorityManagerImpl*
ProcessPriorityManagerImpl::GetSingleton()
{
if (!sSingleton) {
StaticInit();
}
return sSingleton;
}
ProcessPriorityManagerImpl::ProcessPriorityManagerImpl()
: mHighPriority(false)
{
MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default);
RegisterWakeLockObserver(this);
}
ProcessPriorityManagerImpl::~ProcessPriorityManagerImpl()
{
UnregisterWakeLockObserver(this);
}
void
ProcessPriorityManagerImpl::Init()
{
LOG("Starting up. This is the master process.");
// The master process's priority never changes; set it here and then forget
// about it. We'll manage only subprocesses' priorities using the process
// priority manager.
hal::SetProcessPriority(getpid(), PROCESS_PRIORITY_MASTER,
PROCESS_CPU_PRIORITY_NORMAL);
nsCOMPtr<nsIObserverService> os = services::GetObserverService();
if (os) {
os->AddObserver(this, "ipc:content-created", /* ownsWeak */ false);
os->AddObserver(this, "ipc:content-shutdown", /* ownsWeak */ false);
}
}
NS_IMETHODIMP
ProcessPriorityManagerImpl::Observe(
nsISupports* aSubject,
const char* aTopic,
const char16_t* aData)
{
nsDependentCString topic(aTopic);
if (topic.EqualsLiteral("ipc:content-created")) {
ObserveContentParentCreated(aSubject);
} else if (topic.EqualsLiteral("ipc:content-shutdown")) {
ObserveContentParentDestroyed(aSubject);
} else {
MOZ_ASSERT(false);
}
return NS_OK;
}
already_AddRefed<ParticularProcessPriorityManager>
ProcessPriorityManagerImpl::GetParticularProcessPriorityManager(
ContentParent* aContentParent)
{
#ifdef MOZ_NUWA_PROCESS
// Do not attempt to change the priority of the Nuwa process
if (aContentParent->IsNuwaProcess()) {
return nullptr;
}
#endif
nsRefPtr<ParticularProcessPriorityManager> pppm;
uint64_t cpId = aContentParent->ChildID();
mParticularManagers.Get(cpId, &pppm);
if (!pppm) {
pppm = new ParticularProcessPriorityManager(aContentParent);
pppm->Init();
mParticularManagers.Put(cpId, pppm);
FireTestOnlyObserverNotification("process-created",
nsPrintfCString("%lld", cpId));
}
return pppm.forget();
}
void
ProcessPriorityManagerImpl::SetProcessPriority(ContentParent* aContentParent,
ProcessPriority aPriority,
uint32_t aBackgroundLRU)
{
MOZ_ASSERT(aContentParent);
nsRefPtr<ParticularProcessPriorityManager> pppm =
GetParticularProcessPriorityManager(aContentParent);
if (pppm) {
pppm->SetPriorityNow(aPriority, aBackgroundLRU);
}
}
void
ProcessPriorityManagerImpl::ObserveContentParentCreated(
nsISupports* aContentParent)
{
// Do nothing; it's sufficient to get the PPPM. But assign to nsRefPtr so we
// don't leak the already_AddRefed object.
nsCOMPtr<nsIContentParent> cp = do_QueryInterface(aContentParent);
nsRefPtr<ParticularProcessPriorityManager> pppm =
GetParticularProcessPriorityManager(cp->AsContentParent());
}
static PLDHashOperator
EnumerateParticularProcessPriorityManagers(
const uint64_t& aKey,
nsRefPtr<ParticularProcessPriorityManager> aValue,
void* aUserData)
{
nsTArray<nsRefPtr<ParticularProcessPriorityManager> >* aArray =
static_cast<nsTArray<nsRefPtr<ParticularProcessPriorityManager> >*>(aUserData);
aArray->AppendElement(aValue);
return PL_DHASH_NEXT;
}
void
ProcessPriorityManagerImpl::ObserveContentParentDestroyed(nsISupports* aSubject)
{
nsCOMPtr<nsIPropertyBag2> props = do_QueryInterface(aSubject);
NS_ENSURE_TRUE_VOID(props);
uint64_t childID = CONTENT_PROCESS_ID_UNKNOWN;
props->GetPropertyAsUint64(NS_LITERAL_STRING("childID"), &childID);
NS_ENSURE_TRUE_VOID(childID != CONTENT_PROCESS_ID_UNKNOWN);
nsRefPtr<ParticularProcessPriorityManager> pppm;
mParticularManagers.Get(childID, &pppm);
if (pppm) {
pppm->ShutDown();
mParticularManagers.Remove(childID);
if (mHighPriorityChildIDs.Contains(childID)) {
mHighPriorityChildIDs.RemoveEntry(childID);
// We just lost a high-priority process; reset everyone's CPU priorities.
ResetAllCPUPriorities();
}
}
}
void
ProcessPriorityManagerImpl::ResetAllCPUPriorities( void )
{
nsTArray<nsRefPtr<ParticularProcessPriorityManager> > pppms;
mParticularManagers.EnumerateRead(
&EnumerateParticularProcessPriorityManagers,
&pppms);
for (uint32_t i = 0; i < pppms.Length(); i++) {
pppms[i]->ResetCPUPriorityNow();
}
}
bool
ProcessPriorityManagerImpl::OtherProcessHasHighPriority(
ParticularProcessPriorityManager* aParticularManager)
{
if (mHighPriority) {
return true;
} else if (mHighPriorityChildIDs.Contains(aParticularManager->ChildID())) {
return mHighPriorityChildIDs.Count() > 1;
}
return mHighPriorityChildIDs.Count() > 0;
}
bool
ProcessPriorityManagerImpl::ChildProcessHasHighPriority( void )
{
return mHighPriorityChildIDs.Count() > 0;
}
void
ProcessPriorityManagerImpl::NotifyProcessPriorityChanged(
ParticularProcessPriorityManager* aParticularManager,
ProcessPriority aOldPriority)
{
// This priority change can only affect other processes' priorities if we're
// changing to/from FOREGROUND_HIGH.
if (aOldPriority < PROCESS_PRIORITY_FOREGROUND_HIGH &&
aParticularManager->CurrentPriority() <
PROCESS_PRIORITY_FOREGROUND_HIGH) {
return;
}
if (aParticularManager->CurrentPriority() >=
PROCESS_PRIORITY_FOREGROUND_HIGH) {
mHighPriorityChildIDs.PutEntry(aParticularManager->ChildID());
} else {
mHighPriorityChildIDs.RemoveEntry(aParticularManager->ChildID());
}
nsTArray<nsRefPtr<ParticularProcessPriorityManager> > pppms;
mParticularManagers.EnumerateRead(
&EnumerateParticularProcessPriorityManagers,
&pppms);
for (uint32_t i = 0; i < pppms.Length(); i++) {
if (pppms[i] != aParticularManager) {
pppms[i]->ResetCPUPriorityNow();
}
}
}
/* virtual */ void
ProcessPriorityManagerImpl::Notify(const WakeLockInformation& aInfo)
{
/* The main process always has an ID of 0, if it is present in the wake-lock
* information then we explicitly requested a high-priority wake-lock for the
* main process. */
if (aInfo.topic().EqualsLiteral("high-priority")) {
if (aInfo.lockingProcesses().Contains((uint64_t)0)) {
mHighPriority = true;
} else {
mHighPriority = false;
}
/* The main process got a high-priority wakelock change; reset everyone's
* CPU priorities. */
ResetAllCPUPriorities();
LOG("Got wake lock changed event. "
"Now mHighPriorityParent = %d\n", mHighPriority);
}
}
NS_IMPL_ISUPPORTS(ParticularProcessPriorityManager,
nsIObserver,
nsITimerCallback,
nsISupportsWeakReference);
ParticularProcessPriorityManager::ParticularProcessPriorityManager(
ContentParent* aContentParent)
: mContentParent(aContentParent)
, mChildID(aContentParent->ChildID())
, mPriority(PROCESS_PRIORITY_UNKNOWN)
, mCPUPriority(PROCESS_CPU_PRIORITY_NORMAL)
, mHoldsCPUWakeLock(false)
, mHoldsHighPriorityWakeLock(false)
{
MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default);
LOGP("Creating ParticularProcessPriorityManager.");
}
void
ParticularProcessPriorityManager::Init()
{
RegisterWakeLockObserver(this);
nsCOMPtr<nsIObserverService> os = services::GetObserverService();
if (os) {
os->AddObserver(this, "audio-channel-process-changed", /* ownsWeak */ true);
os->AddObserver(this, "remote-browser-shown", /* ownsWeak */ true);
os->AddObserver(this, "ipc:browser-destroyed", /* ownsWeak */ true);
os->AddObserver(this, "frameloader-visible-changed", /* ownsWeak */ true);
}
// This process may already hold the CPU lock; for example, our parent may
// have acquired it on our behalf.
WakeLockInformation info1, info2;
GetWakeLockInfo(NS_LITERAL_STRING("cpu"), &info1);
mHoldsCPUWakeLock = info1.lockingProcesses().Contains(ChildID());
GetWakeLockInfo(NS_LITERAL_STRING("high-priority"), &info2);
mHoldsHighPriorityWakeLock = info2.lockingProcesses().Contains(ChildID());
LOGP("Done starting up. mHoldsCPUWakeLock=%d, mHoldsHighPriorityWakeLock=%d",
mHoldsCPUWakeLock, mHoldsHighPriorityWakeLock);
}
ParticularProcessPriorityManager::~ParticularProcessPriorityManager()
{
LOGP("Destroying ParticularProcessPriorityManager.");
// Unregister our wake lock observer if ShutDown hasn't been called. (The
// wake lock observer takes raw refs, so we don't want to take chances here!)
// We don't call UnregisterWakeLockObserver unconditionally because the code
// will print a warning if it's called unnecessarily.
if (mContentParent) {
UnregisterWakeLockObserver(this);
}
}
/* virtual */ void
ParticularProcessPriorityManager::Notify(const WakeLockInformation& aInfo)
{
if (!mContentParent) {
// We've been shut down.
return;
}
bool* dest = nullptr;
if (aInfo.topic().EqualsLiteral("cpu")) {
dest = &mHoldsCPUWakeLock;
} else if (aInfo.topic().EqualsLiteral("high-priority")) {
dest = &mHoldsHighPriorityWakeLock;
}
if (dest) {
bool thisProcessLocks = aInfo.lockingProcesses().Contains(ChildID());
if (thisProcessLocks != *dest) {
*dest = thisProcessLocks;
LOGP("Got wake lock changed event. "
"Now mHoldsCPUWakeLock=%d, mHoldsHighPriorityWakeLock=%d",
mHoldsCPUWakeLock, mHoldsHighPriorityWakeLock);
ResetPriority();
}
}
}
NS_IMETHODIMP
ParticularProcessPriorityManager::Observe(nsISupports* aSubject,
const char* aTopic,
const char16_t* aData)
{
if (!mContentParent) {
// We've been shut down.
return NS_OK;
}
nsDependentCString topic(aTopic);
if (topic.EqualsLiteral("audio-channel-process-changed")) {
OnAudioChannelProcessChanged(aSubject);
} else if (topic.EqualsLiteral("remote-browser-shown")) {
OnRemoteBrowserFrameShown(aSubject);
} else if (topic.EqualsLiteral("ipc:browser-destroyed")) {
OnTabParentDestroyed(aSubject);
} else if (topic.EqualsLiteral("frameloader-visible-changed")) {
OnFrameloaderVisibleChanged(aSubject);
} else {
MOZ_ASSERT(false);
}
return NS_OK;
}
uint64_t
ParticularProcessPriorityManager::ChildID() const
{
// We have to cache mContentParent->ChildID() instead of getting it from the
// ContentParent each time because after ShutDown() is called, mContentParent
// is null. If we didn't cache ChildID(), then we wouldn't be able to run
// LOGP() after ShutDown().
return mChildID;
}
int32_t
ParticularProcessPriorityManager::Pid() const
{
return mContentParent ? mContentParent->Pid() : -1;
}
bool
ParticularProcessPriorityManager::IsPreallocated() const
{
return mContentParent ? mContentParent->IsPreallocated() : false;
}
const nsAutoCString&
ParticularProcessPriorityManager::NameWithComma()
{
mNameWithComma.Truncate();
if (!mContentParent) {
return mNameWithComma; // empty string
}
nsAutoString name;
mContentParent->FriendlyName(name);
if (name.IsEmpty()) {
return mNameWithComma; // empty string
}
mNameWithComma = NS_ConvertUTF16toUTF8(name);
mNameWithComma.AppendLiteral(", ");
return mNameWithComma;
}
void
ParticularProcessPriorityManager::OnAudioChannelProcessChanged(nsISupports* aSubject)
{
nsCOMPtr<nsIPropertyBag2> props = do_QueryInterface(aSubject);
NS_ENSURE_TRUE_VOID(props);
uint64_t childID = CONTENT_PROCESS_ID_UNKNOWN;
props->GetPropertyAsUint64(NS_LITERAL_STRING("childID"), &childID);
if (childID == ChildID()) {
ResetPriority();
}
}
void
ParticularProcessPriorityManager::OnRemoteBrowserFrameShown(nsISupports* aSubject)
{
nsCOMPtr<nsIFrameLoader> fl = do_QueryInterface(aSubject);
NS_ENSURE_TRUE_VOID(fl);
TabParent* tp = TabParent::GetFrom(fl);
NS_ENSURE_TRUE_VOID(tp);
MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default);
if (tp->Manager() != mContentParent) {
return;
}
// Ignore notifications that aren't from a BrowserOrApp
bool isBrowserOrApp;
fl->GetOwnerIsBrowserOrAppFrame(&isBrowserOrApp);
if (isBrowserOrApp) {
ResetPriority();
}
nsCOMPtr<nsIObserverService> os = services::GetObserverService();
if (os) {
os->RemoveObserver(this, "remote-browser-shown");
}
}
void
ParticularProcessPriorityManager::OnTabParentDestroyed(nsISupports* aSubject)
{
nsCOMPtr<nsITabParent> tp = do_QueryInterface(aSubject);
NS_ENSURE_TRUE_VOID(tp);
MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default);
if (TabParent::GetFrom(tp)->Manager() != mContentParent) {
return;
}
ResetPriority();
}
void
ParticularProcessPriorityManager::OnFrameloaderVisibleChanged(nsISupports* aSubject)
{
nsCOMPtr<nsIFrameLoader> fl = do_QueryInterface(aSubject);
NS_ENSURE_TRUE_VOID(fl);
TabParent* tp = TabParent::GetFrom(fl);
if (!tp) {
return;
}
MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default);
if (tp->Manager() != mContentParent) {
return;
}
// Most of the time when something changes in a process we call
// ResetPriority(), giving a grace period before downgrading its priority.
// But notice that here don't give a grace period: We call ResetPriorityNow()
// instead.
//
// We do this because we're reacting here to a setVisibility() call, which is
// an explicit signal from the process embedder that we should re-prioritize
// a process. If we gave a grace period in response to setVisibility()
// calls, it would be impossible for the embedder to explicitly prioritize
// processes and prevent e.g. the case where we switch which process is in
// the foreground and, during the old fg processs's grace period, it OOMs the
// new fg process.
ResetPriorityNow();
}
void
ParticularProcessPriorityManager::ResetPriority()
{
ProcessPriority processPriority = ComputePriority();
if (mPriority == PROCESS_PRIORITY_UNKNOWN ||
mPriority > processPriority) {
// Apps set at a perceivable background priority are often playing media.
// Most media will have short gaps while changing tracks between songs,
// switching videos, etc. Give these apps a longer grace period so they
// can get their next track started, if there is one, before getting
// downgraded.
if (mPriority == PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE) {
ScheduleResetPriority("backgroundPerceivableGracePeriodMS");
} else {
ScheduleResetPriority("backgroundGracePeriodMS");
}
return;
}
SetPriorityNow(processPriority);
}
void
ParticularProcessPriorityManager::ResetPriorityNow()
{
SetPriorityNow(ComputePriority());
}
void
ParticularProcessPriorityManager::ScheduleResetPriority(const char* aTimeoutPref)
{
if (mResetPriorityTimer) {
LOGP("ScheduleResetPriority bailing; the timer is already running.");
return;
}
uint32_t timeout = Preferences::GetUint(
nsPrintfCString("dom.ipc.processPriorityManager.%s", aTimeoutPref).get());
LOGP("Scheduling reset timer to fire in %dms.", timeout);
mResetPriorityTimer = do_CreateInstance("@mozilla.org/timer;1");
mResetPriorityTimer->InitWithCallback(this, timeout, nsITimer::TYPE_ONE_SHOT);
}
NS_IMETHODIMP
ParticularProcessPriorityManager::Notify(nsITimer* aTimer)
{
LOGP("Reset priority timer callback; about to ResetPriorityNow.");
ResetPriorityNow();
mResetPriorityTimer = nullptr;
return NS_OK;
}
bool
ParticularProcessPriorityManager::HasAppType(const char* aAppType)
{
const InfallibleTArray<PBrowserParent*>& browsers =
mContentParent->ManagedPBrowserParent();
for (uint32_t i = 0; i < browsers.Length(); i++) {
nsAutoString appType;
TabParent::GetFrom(browsers[i])->GetAppType(appType);
if (appType.EqualsASCII(aAppType)) {
return true;
}
}
return false;
}
bool
ParticularProcessPriorityManager::IsExpectingSystemMessage()
{
const InfallibleTArray<PBrowserParent*>& browsers =
mContentParent->ManagedPBrowserParent();
for (uint32_t i = 0; i < browsers.Length(); i++) {
TabParent* tp = TabParent::GetFrom(browsers[i]);
nsCOMPtr<nsIMozBrowserFrame> bf = do_QueryInterface(tp->GetOwnerElement());
if (!bf) {
continue;
}
if (bf->GetIsExpectingSystemMessage()) {
return true;
}
}
return false;
}
ProcessPriority
ParticularProcessPriorityManager::CurrentPriority()
{
return mPriority;
}
ProcessPriority
ParticularProcessPriorityManager::ComputePriority()
{
if ((mHoldsCPUWakeLock || mHoldsHighPriorityWakeLock) &&
HasAppType("critical")) {
return PROCESS_PRIORITY_FOREGROUND_HIGH;
}
bool isVisible = false;
const InfallibleTArray<PBrowserParent*>& browsers =
mContentParent->ManagedPBrowserParent();
for (uint32_t i = 0; i < browsers.Length(); i++) {
if (TabParent::GetFrom(browsers[i])->IsVisible()) {
isVisible = true;
break;
}
}
if (isVisible) {
return HasAppType("inputmethod") ?
PROCESS_PRIORITY_FOREGROUND_KEYBOARD :
PROCESS_PRIORITY_FOREGROUND;
}
if ((mHoldsCPUWakeLock || mHoldsHighPriorityWakeLock) &&
IsExpectingSystemMessage()) {
return PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE;
}
AudioChannelService* service = AudioChannelService::GetOrCreateAudioChannelService();
if (service->ProcessContentOrNormalChannelIsActive(ChildID())) {
return PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE;
}
return HasAppType("homescreen") ?
PROCESS_PRIORITY_BACKGROUND_HOMESCREEN :
PROCESS_PRIORITY_BACKGROUND;
}
ProcessCPUPriority
ParticularProcessPriorityManager::ComputeCPUPriority(ProcessPriority aPriority)
{
if (aPriority == PROCESS_PRIORITY_PREALLOC) {
return PROCESS_CPU_PRIORITY_LOW;
}
if (aPriority >= PROCESS_PRIORITY_FOREGROUND_HIGH) {
return PROCESS_CPU_PRIORITY_NORMAL;
}
return ProcessPriorityManagerImpl::GetSingleton()->
OtherProcessHasHighPriority(this) ?
PROCESS_CPU_PRIORITY_LOW :
PROCESS_CPU_PRIORITY_NORMAL;
}
void
ParticularProcessPriorityManager::ResetCPUPriorityNow()
{
SetPriorityNow(mPriority);
}
void
ParticularProcessPriorityManager::SetPriorityNow(ProcessPriority aPriority,
uint32_t aBackgroundLRU)
{
SetPriorityNow(aPriority, ComputeCPUPriority(aPriority), aBackgroundLRU);
}
void
ParticularProcessPriorityManager::SetPriorityNow(ProcessPriority aPriority,
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)) {
return;
}
// If the prefs were disabled after this ParticularProcessPriorityManager was
// created, we can at least avoid any further calls to
// hal::SetProcessPriority. Supporting dynamic enabling/disabling of the
// ProcessPriorityManager is mostly for testing.
if (!ProcessPriorityManagerImpl::PrefsEnabled()) {
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));
ProcessPriority oldPriority = mPriority;
mPriority = aPriority;
mCPUPriority = aCPUPriority;
hal::SetProcessPriority(Pid(), mPriority, mCPUPriority);
if (oldPriority != mPriority) {
unused << mContentParent->SendNotifyProcessPriorityChanged(mPriority);
}
if (aPriority < PROCESS_PRIORITY_FOREGROUND) {
unused << mContentParent->SendFlushMemory(NS_LITERAL_STRING("low-memory"));
}
FireTestOnlyObserverNotification("process-priority-set",
ProcessPriorityToString(mPriority, mCPUPriority));
if (oldPriority != mPriority) {
ProcessPriorityManagerImpl::GetSingleton()->
NotifyProcessPriorityChanged(this, oldPriority);
}
}
void
ParticularProcessPriorityManager::ShutDown()
{
MOZ_ASSERT(mContentParent);
UnregisterWakeLockObserver(this);
if (mResetPriorityTimer) {
mResetPriorityTimer->Cancel();
mResetPriorityTimer = nullptr;
}
if (mPriority == PROCESS_PRIORITY_BACKGROUND && !IsPreallocated()) {
ProcessPriorityManager::RemoveFromBackgroundLRUPool(mContentParent);
}
mContentParent = nullptr;
}
void
ProcessPriorityManagerImpl::FireTestOnlyObserverNotification(
const char* aTopic,
const nsACString& aData /* = EmptyCString() */)
{
if (!Preferences::GetBool("dom.ipc.processPriorityManager.testMode")) {
return;
}
nsCOMPtr<nsIObserverService> os = services::GetObserverService();
NS_ENSURE_TRUE_VOID(os);
nsPrintfCString topic("process-priority-manager:TEST-ONLY:%s", aTopic);
LOG("Notifying observer %s, data %s",
topic.get(), PromiseFlatCString(aData).get());
os->NotifyObservers(nullptr, topic.get(), NS_ConvertUTF8toUTF16(aData).get());
}
void
ParticularProcessPriorityManager::FireTestOnlyObserverNotification(
const char* aTopic,
const char* aData /* = nullptr */ )
{
if (!Preferences::GetBool("dom.ipc.processPriorityManager.testMode")) {
return;
}
nsAutoCString data;
if (aData) {
data.AppendASCII(aData);
}
FireTestOnlyObserverNotification(aTopic, data);
}
void
ParticularProcessPriorityManager::FireTestOnlyObserverNotification(
const char* aTopic,
const nsACString& aData /* = EmptyCString() */)
{
if (!Preferences::GetBool("dom.ipc.processPriorityManager.testMode")) {
return;
}
nsAutoCString data(nsPrintfCString("%lld", ChildID()));
if (!aData.IsEmpty()) {
data.Append(':');
data.Append(aData);
}
// ProcessPriorityManagerImpl::GetSingleton() is guaranteed not to return
// null, since ProcessPriorityManagerImpl is the only class which creates
// ParticularProcessPriorityManagers.
ProcessPriorityManagerImpl::GetSingleton()->
FireTestOnlyObserverNotification(aTopic, data);
}
StaticRefPtr<ProcessPriorityManagerChild>
ProcessPriorityManagerChild::sSingleton;
/* static */ void
ProcessPriorityManagerChild::StaticInit()
{
if (!sSingleton) {
sSingleton = new ProcessPriorityManagerChild();
sSingleton->Init();
ClearOnShutdown(&sSingleton);
}
}
/* static */ ProcessPriorityManagerChild*
ProcessPriorityManagerChild::Singleton()
{
StaticInit();
return sSingleton;
}
NS_IMPL_ISUPPORTS(ProcessPriorityManagerChild,
nsIObserver)
ProcessPriorityManagerChild::ProcessPriorityManagerChild()
{
if (XRE_GetProcessType() == GeckoProcessType_Default) {
mCachedPriority = PROCESS_PRIORITY_MASTER;
} else {
mCachedPriority = PROCESS_PRIORITY_UNKNOWN;
}
}
void
ProcessPriorityManagerChild::Init()
{
// The process priority should only be changed in child processes; don't even
// bother listening for changes if we're in the main process.
if (XRE_GetProcessType() != GeckoProcessType_Default) {
nsCOMPtr<nsIObserverService> os = services::GetObserverService();
NS_ENSURE_TRUE_VOID(os);
os->AddObserver(this, "ipc:process-priority-changed", /* weak = */ false);
}
}
NS_IMETHODIMP
ProcessPriorityManagerChild::Observe(
nsISupports* aSubject,
const char* aTopic,
const char16_t* aData)
{
MOZ_ASSERT(!strcmp(aTopic, "ipc:process-priority-changed"));
nsCOMPtr<nsIPropertyBag2> props = do_QueryInterface(aSubject);
NS_ENSURE_TRUE(props, NS_OK);
int32_t priority = static_cast<int32_t>(PROCESS_PRIORITY_UNKNOWN);
props->GetPropertyAsInt32(NS_LITERAL_STRING("priority"), &priority);
NS_ENSURE_TRUE(ProcessPriority(priority) != PROCESS_PRIORITY_UNKNOWN, NS_OK);
mCachedPriority = static_cast<ProcessPriority>(priority);
return NS_OK;
}
bool
ProcessPriorityManagerChild::CurrentProcessIsForeground()
{
return mCachedPriority == PROCESS_PRIORITY_UNKNOWN ||
mCachedPriority >= PROCESS_PRIORITY_FOREGROUND;
}
bool
ProcessPriorityManagerChild::CurrentProcessIsHighPriority()
{
return mCachedPriority == PROCESS_PRIORITY_UNKNOWN ||
mCachedPriority >= PROCESS_PRIORITY_FOREGROUND_HIGH;
}
/* 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 {
/* static */ void
ProcessPriorityManager::Init()
{
ProcessPriorityManagerImpl::StaticInit();
ProcessPriorityManagerChild::StaticInit();
}
/* static */ void
ProcessPriorityManager::SetProcessPriority(ContentParent* aContentParent,
ProcessPriority aPriority)
{
MOZ_ASSERT(aContentParent);
ProcessPriorityManagerImpl* singleton =
ProcessPriorityManagerImpl::GetSingleton();
if (singleton) {
singleton->SetProcessPriority(aContentParent, aPriority);
}
}
/* 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()
{
return ProcessPriorityManagerChild::Singleton()->
CurrentProcessIsForeground();
}
/* static */ bool
ProcessPriorityManager::AnyProcessHasHighPriority()
{
ProcessPriorityManagerImpl* singleton =
ProcessPriorityManagerImpl::GetSingleton();
if (singleton) {
return singleton->ChildProcessHasHighPriority();
} else {
return ProcessPriorityManagerChild::Singleton()->
CurrentProcessIsHighPriority();
}
}
} // namespace mozilla
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку