diff options
Diffstat (limited to 'dom/ipc/ProcessPriorityManager.cpp')
| -rw-r--r-- | dom/ipc/ProcessPriorityManager.cpp | 1454 |
1 files changed, 1454 insertions, 0 deletions
diff --git a/dom/ipc/ProcessPriorityManager.cpp b/dom/ipc/ProcessPriorityManager.cpp new file mode 100644 index 000000000..80839796d --- /dev/null +++ b/dom/ipc/ProcessPriorityManager.cpp @@ -0,0 +1,1454 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* 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/IntegerPrintfMacros.h" +#include "mozilla/Preferences.h" +#include "mozilla/Services.h" +#include "mozilla/Unused.h" +#include "AudioChannelService.h" +#include "mozilla/Logging.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" +#include "nsCRT.h" + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::hal; + +#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=%" PRIu64 ", pid=%d] " fmt, \ + NameWithComma().get(), \ + static_cast<uint64_t>(ChildID()), Pid(), ## __VA_ARGS__) + +#elif defined(ENABLE_LOGGING) +# define LOG(fmt, ...) \ + printf("ProcessPriorityManager - " fmt "\n", ##__VA_ARGS__) +# define LOGP(fmt, ...) \ + printf("ProcessPriorityManager[%schild-id=%" PRIu64 ", pid=%d] - " \ + fmt "\n", \ + NameWithComma().get(), \ + static_cast<uint64_t>(ChildID()), Pid(), ##__VA_ARGS__) +#else + static LogModule* + GetPPMLog() + { + static LazyLogModule sLog("ProcessPriorityManager"); + return sLog; + } +# define LOG(fmt, ...) \ + MOZ_LOG(GetPPMLog(), LogLevel::Debug, \ + ("ProcessPriorityManager - " fmt, ##__VA_ARGS__)) +# define LOGP(fmt, ...) \ + MOZ_LOG(GetPPMLog(), LogLevel::Debug, \ + ("ProcessPriorityManager[%schild-id=%" PRIu64 ", pid=%d] - " fmt, \ + NameWithComma().get(), \ + static_cast<uint64_t>(ChildID()), Pid(), ##__VA_ARGS__)) +#endif + +namespace { + +class ParticularProcessPriorityManager; + +class ProcessLRUPool final +{ +public: + /** + * Creates a new process LRU pool for the specified priority. + */ + explicit ProcessLRUPool(ProcessPriority aPriority); + + /** + * Used to remove a particular process priority manager from the LRU pool + * when the associated ContentParent is destroyed or its priority changes. + */ + void Remove(ParticularProcessPriorityManager* aParticularManager); + + /** + * Used to add a particular process priority manager into the LRU pool when + * the associated ContentParent's priority changes. + */ + void Add(ParticularProcessPriorityManager* aParticularManager); + +private: + ProcessPriority mPriority; + uint32_t mLRUPoolLevels; + nsTArray<ParticularProcessPriorityManager*> mLRUPool; + + uint32_t CalculateLRULevel(uint32_t aLRUPoolIndex); + + void AdjustLRUValues( + nsTArray<ParticularProcessPriorityManager*>::index_type aStart, + bool removed); + + DISALLOW_EVIL_CONSTRUCTORS(ProcessLRUPool); +}; + +/** + * 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 final + : public nsIObserver + , public WakeLockObserver + , public nsSupportsWeakReference +{ +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(); + static bool TestMode(); + + NS_DECL_ISUPPORTS + NS_DECL_NSIOBSERVER + + /** + * This function implements ProcessPriorityManager::SetProcessPriority. + */ + void SetProcessPriority(ContentParent* aContentParent, + ProcessPriority aPriority, + uint32_t aLRU = 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 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) override; + + /** + * Prevents processes from changing priority until unfrozen. + */ + void Freeze(); + + /** + * Allow process' priorities to change again. This will immediately adjust + * processes whose priority change did not happen because of the freeze. + */ + void Unfreeze(); + + /** + * Call ShutDown before destroying the ProcessPriorityManager because + * WakeLockObserver hols a strong reference to it. + */ + void ShutDown(); + +private: + static bool sPrefsEnabled; + static bool sRemoteTabsDisabled; + static bool sTestMode; + static bool sPrefListenersRegistered; + static bool sInitialized; + static bool sFrozen; + 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 ObserveScreenStateChanged(const char16_t* aData); + + nsDataHashtable<nsUint64HashKey, RefPtr<ParticularProcessPriorityManager> > + mParticularManagers; + + /** True if the main process is holding a high-priority wakelock */ + bool mHighPriority; + + /** Contains the PIDs of child processes holding high-priority wakelocks */ + nsTHashtable<nsUint64HashKey> mHighPriorityChildIDs; + + /** Contains a pseudo-LRU list of background processes */ + ProcessLRUPool mBackgroundLRUPool; + + /** Contains a pseudo-LRU list of background-perceivable processes */ + ProcessLRUPool mBackgroundPerceivableLRUPool; +}; + +/** + * This singleton class implements the parts of the process priority manager + * that are available from all processes. + */ +class ProcessPriorityManagerChild 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 final + : public WakeLockObserver + , public nsIObserver + , public nsITimerCallback + , public nsSupportsWeakReference +{ + ~ParticularProcessPriorityManager(); +public: + explicit ParticularProcessPriorityManager(ContentParent* aContentParent, + bool aFrozen = false); + + NS_DECL_ISUPPORTS + NS_DECL_NSIOBSERVER + NS_DECL_NSITIMERCALLBACK + + virtual void Notify(const WakeLockInformation& aInfo) override; + static void StaticInit(); + 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 OnActivityOpened(const char16_t* aData); + void OnActivityClosed(const char16_t* aData); + + ProcessPriority CurrentPriority(); + ProcessPriority ComputePriority(); + + enum TimeoutPref { + BACKGROUND_PERCEIVABLE_GRACE_PERIOD, + BACKGROUND_GRACE_PERIOD, + }; + + void ScheduleResetPriority(TimeoutPref aTimeoutPref); + void ResetPriority(); + void ResetPriorityNow(); + void SetPriorityNow(ProcessPriority aPriority, uint32_t aLRU = 0); + void Freeze(); + void Unfreeze(); + + void ShutDown(); + +private: + static uint32_t sBackgroundPerceivableGracePeriodMS; + static uint32_t sBackgroundGracePeriodMS; + + 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; + uint32_t mLRU; + bool mHoldsCPUWakeLock; + bool mHoldsHighPriorityWakeLock; + bool mIsActivityOpener; + bool mFrozen; + + /** + * Used to implement NameWithComma(). + */ + nsAutoCString mNameWithComma; + + nsCOMPtr<nsITimer> mResetPriorityTimer; +}; + +/* static */ bool ProcessPriorityManagerImpl::sInitialized = false; +/* static */ bool ProcessPriorityManagerImpl::sPrefsEnabled = false; +/* static */ bool ProcessPriorityManagerImpl::sRemoteTabsDisabled = true; +/* static */ bool ProcessPriorityManagerImpl::sTestMode = false; +/* static */ bool ProcessPriorityManagerImpl::sPrefListenersRegistered = false; +/* static */ bool ProcessPriorityManagerImpl::sFrozen = false; +/* static */ StaticRefPtr<ProcessPriorityManagerImpl> + ProcessPriorityManagerImpl::sSingleton; +/* static */ uint32_t ParticularProcessPriorityManager::sBackgroundPerceivableGracePeriodMS = 0; +/* static */ uint32_t ParticularProcessPriorityManager::sBackgroundGracePeriodMS = 0; + +NS_IMPL_ISUPPORTS(ProcessPriorityManagerImpl, + nsIObserver, + nsISupportsWeakReference); + +/* static */ void +ProcessPriorityManagerImpl::PrefChangedCallback(const char* aPref, + void* aClosure) +{ + StaticInit(); + if (!PrefsEnabled() && sSingleton) { + sSingleton->ShutDown(); + sSingleton = nullptr; + sInitialized = false; + } +} + +/* static */ bool +ProcessPriorityManagerImpl::PrefsEnabled() +{ + return sPrefsEnabled && !sRemoteTabsDisabled; +} + +/* static */ bool +ProcessPriorityManagerImpl::TestMode() +{ + return sTestMode; +} + +/* static */ void +ProcessPriorityManagerImpl::StaticInit() +{ + if (sInitialized) { + return; + } + + // The process priority manager is main-process only. + if (!XRE_IsParentProcess()) { + sInitialized = true; + return; + } + + if (!sPrefListenersRegistered) { + Preferences::AddBoolVarCache(&sPrefsEnabled, + "dom.ipc.processPriorityManager.enabled"); + Preferences::AddBoolVarCache(&sRemoteTabsDisabled, + "dom.ipc.tabs.disabled"); + Preferences::AddBoolVarCache(&sTestMode, + "dom.ipc.processPriorityManager.testMode"); + } + + // 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) + , mBackgroundLRUPool(PROCESS_PRIORITY_BACKGROUND) + , mBackgroundPerceivableLRUPool(PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE) +{ + MOZ_ASSERT(XRE_IsParentProcess()); + RegisterWakeLockObserver(this); +} + +ProcessPriorityManagerImpl::~ProcessPriorityManagerImpl() +{ + ShutDown(); +} + +void +ProcessPriorityManagerImpl::ShutDown() +{ + 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); + + nsCOMPtr<nsIObserverService> os = services::GetObserverService(); + if (os) { + os->AddObserver(this, "ipc:content-created", /* ownsWeak */ true); + os->AddObserver(this, "ipc:content-shutdown", /* ownsWeak */ true); + os->AddObserver(this, "screen-state-changed", /* ownsWeak */ true); + } +} + +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 if (topic.EqualsLiteral("screen-state-changed")) { + ObserveScreenStateChanged(aData); + } else { + MOZ_ASSERT(false); + } + + return NS_OK; +} + +already_AddRefed<ParticularProcessPriorityManager> +ProcessPriorityManagerImpl::GetParticularProcessPriorityManager( + ContentParent* aContentParent) +{ + RefPtr<ParticularProcessPriorityManager> pppm; + uint64_t cpId = aContentParent->ChildID(); + mParticularManagers.Get(cpId, &pppm); + if (!pppm) { + pppm = new ParticularProcessPriorityManager(aContentParent, sFrozen); + pppm->Init(); + mParticularManagers.Put(cpId, pppm); + + FireTestOnlyObserverNotification("process-created", + nsPrintfCString("%lld", cpId)); + } + + return pppm.forget(); +} + +void +ProcessPriorityManagerImpl::SetProcessPriority(ContentParent* aContentParent, + ProcessPriority aPriority, + uint32_t aLRU) +{ + MOZ_ASSERT(aContentParent); + RefPtr<ParticularProcessPriorityManager> pppm = + GetParticularProcessPriorityManager(aContentParent); + if (pppm) { + pppm->SetPriorityNow(aPriority, aLRU); + } +} + +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); + RefPtr<ParticularProcessPriorityManager> pppm = + GetParticularProcessPriorityManager(cp->AsContentParent()); +} + +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); + + RefPtr<ParticularProcessPriorityManager> pppm; + mParticularManagers.Get(childID, &pppm); + if (pppm) { + // Unconditionally remove the manager from the pools + mBackgroundLRUPool.Remove(pppm); + mBackgroundPerceivableLRUPool.Remove(pppm); + + pppm->ShutDown(); + + mParticularManagers.Remove(childID); + + mHighPriorityChildIDs.RemoveEntry(childID); + } +} + +void +ProcessPriorityManagerImpl::ObserveScreenStateChanged(const char16_t* aData) +{ + if (NS_LITERAL_STRING("on").Equals(aData)) { + sFrozen = false; + for (auto iter = mParticularManagers.Iter(); !iter.Done(); iter.Next()) { + iter.UserData()->Unfreeze(); + } + } else { + sFrozen = true; + for (auto iter = mParticularManagers.Iter(); !iter.Done(); iter.Next()) { + iter.UserData()->Freeze(); + } + } +} + +bool +ProcessPriorityManagerImpl::ChildProcessHasHighPriority( void ) +{ + return mHighPriorityChildIDs.Count() > 0; +} + +void +ProcessPriorityManagerImpl::NotifyProcessPriorityChanged( + ParticularProcessPriorityManager* aParticularManager, + ProcessPriority aOldPriority) +{ + ProcessPriority newPriority = aParticularManager->CurrentPriority(); + bool isPreallocated = aParticularManager->IsPreallocated(); + + if (newPriority == PROCESS_PRIORITY_BACKGROUND && + aOldPriority != PROCESS_PRIORITY_BACKGROUND && + !isPreallocated) { + mBackgroundLRUPool.Add(aParticularManager); + } else if (newPriority != PROCESS_PRIORITY_BACKGROUND && + aOldPriority == PROCESS_PRIORITY_BACKGROUND && + !isPreallocated) { + mBackgroundLRUPool.Remove(aParticularManager); + } + + if (newPriority == PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE && + aOldPriority != PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE) { + mBackgroundPerceivableLRUPool.Add(aParticularManager); + } else if (newPriority != PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE && + aOldPriority == PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE) { + mBackgroundPerceivableLRUPool.Remove(aParticularManager); + } + + if (newPriority >= PROCESS_PRIORITY_FOREGROUND_HIGH && + aOldPriority < PROCESS_PRIORITY_FOREGROUND_HIGH) { + mHighPriorityChildIDs.PutEntry(aParticularManager->ChildID()); + } else if (newPriority < PROCESS_PRIORITY_FOREGROUND_HIGH && + aOldPriority >= PROCESS_PRIORITY_FOREGROUND_HIGH) { + mHighPriorityChildIDs.RemoveEntry(aParticularManager->ChildID()); + } +} + +/* 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; + } + + LOG("Got wake lock changed event. " + "Now mHighPriorityParent = %d\n", mHighPriority); + } +} + +NS_IMPL_ISUPPORTS(ParticularProcessPriorityManager, + nsIObserver, + nsITimerCallback, + nsISupportsWeakReference); + +ParticularProcessPriorityManager::ParticularProcessPriorityManager( + ContentParent* aContentParent, bool aFrozen) + : mContentParent(aContentParent) + , mChildID(aContentParent->ChildID()) + , mPriority(PROCESS_PRIORITY_UNKNOWN) + , mLRU(0) + , mHoldsCPUWakeLock(false) + , mHoldsHighPriorityWakeLock(false) + , mIsActivityOpener(false) + , mFrozen(aFrozen) +{ + MOZ_ASSERT(XRE_IsParentProcess()); + LOGP("Creating ParticularProcessPriorityManager."); +} + +void +ParticularProcessPriorityManager::StaticInit() +{ + Preferences::AddUintVarCache(&sBackgroundPerceivableGracePeriodMS, + "dom.ipc.processPriorityManager.backgroundPerceivableGracePeriodMS"); + Preferences::AddUintVarCache(&sBackgroundGracePeriodMS, + "dom.ipc.processPriorityManager.backgroundGracePeriodMS"); +} + +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); + os->AddObserver(this, "activity-opened", /* ownsWeak */ true); + os->AddObserver(this, "activity-closed", /* 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 if (topic.EqualsLiteral("activity-opened")) { + OnActivityOpened(aData); + } else if (topic.EqualsLiteral("activity-closed")) { + OnActivityClosed(aData); + } 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_IsParentProcess()); + if (tp->Manager() != mContentParent) { + return; + } + + // Ignore notifications that aren't from a BrowserOrApp + bool isMozBrowserOrApp; + fl->GetOwnerIsMozBrowserOrAppFrame(&isMozBrowserOrApp); + if (isMozBrowserOrApp) { + 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_IsParentProcess()); + if (TabParent::GetFrom(tp)->Manager() != mContentParent) { + return; + } + + ResetPriority(); +} + +void +ParticularProcessPriorityManager::OnFrameloaderVisibleChanged(nsISupports* aSubject) +{ + nsCOMPtr<nsIFrameLoader> fl = do_QueryInterface(aSubject); + NS_ENSURE_TRUE_VOID(fl); + + if (mFrozen) { + return; // Ignore visibility changes when the screen is off + } + + TabParent* tp = TabParent::GetFrom(fl); + if (!tp) { + return; + } + + MOZ_ASSERT(XRE_IsParentProcess()); + 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::OnActivityOpened(const char16_t* aData) +{ + uint64_t childID = nsCRT::atoll(NS_ConvertUTF16toUTF8(aData).get()); + + if (ChildID() == childID) { + LOGP("Marking as activity opener"); + mIsActivityOpener = true; + ResetPriority(); + } +} + +void +ParticularProcessPriorityManager::OnActivityClosed(const char16_t* aData) +{ + uint64_t childID = nsCRT::atoll(NS_ConvertUTF16toUTF8(aData).get()); + + if (ChildID() == childID) { + LOGP("Unmarking as activity opener"); + mIsActivityOpener = false; + ResetPriority(); + } +} + +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(BACKGROUND_PERCEIVABLE_GRACE_PERIOD); + } else { + ScheduleResetPriority(BACKGROUND_GRACE_PERIOD); + } + return; + } + + SetPriorityNow(processPriority); +} + +void +ParticularProcessPriorityManager::ResetPriorityNow() +{ + SetPriorityNow(ComputePriority()); +} + +void +ParticularProcessPriorityManager::ScheduleResetPriority(TimeoutPref aTimeoutPref) +{ + if (mResetPriorityTimer) { + LOGP("ScheduleResetPriority bailing; the timer is already running."); + return; + } + + uint32_t timeout = 0; + switch (aTimeoutPref) { + case BACKGROUND_PERCEIVABLE_GRACE_PERIOD: + timeout = sBackgroundPerceivableGracePeriodMS; + break; + case BACKGROUND_GRACE_PERIOD: + timeout = sBackgroundGracePeriodMS; + break; + default: + MOZ_ASSERT(false, "Unrecognized timeout pref"); + break; + } + + LOGP("Scheduling reset timer to fire in %dms.", timeout); + mResetPriorityTimer = do_CreateInstance(NS_TIMER_CONTRACTID); + 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 ManagedContainer<PBrowserParent>& browsers = + mContentParent->ManagedPBrowserParent(); + for (auto iter = browsers.ConstIter(); !iter.Done(); iter.Next()) { + nsAutoString appType; + TabParent::GetFrom(iter.Get()->GetKey())->GetAppType(appType); + if (appType.EqualsASCII(aAppType)) { + return true; + } + } + + return false; +} + +bool +ParticularProcessPriorityManager::IsExpectingSystemMessage() +{ + const ManagedContainer<PBrowserParent>& browsers = + mContentParent->ManagedPBrowserParent(); + for (auto iter = browsers.ConstIter(); !iter.Done(); iter.Next()) { + TabParent* tp = TabParent::GetFrom(iter.Get()->GetKey()); + nsCOMPtr<nsIMozBrowserFrame> bf = do_QueryInterface(tp->GetOwnerElement()); + if (!bf) { + continue; + } + } + + return false; +} + +ProcessPriority +ParticularProcessPriorityManager::CurrentPriority() +{ + return mPriority; +} + +ProcessPriority +ParticularProcessPriorityManager::ComputePriority() +{ + if ((mHoldsCPUWakeLock || mHoldsHighPriorityWakeLock) && + HasAppType("critical")) { + return PROCESS_PRIORITY_FOREGROUND_HIGH; + } + + bool isVisible = false; + const ManagedContainer<PBrowserParent>& browsers = + mContentParent->ManagedPBrowserParent(); + for (auto iter = browsers.ConstIter(); !iter.Done(); iter.Next()) { + if (TabParent::GetFrom(iter.Get()->GetKey())->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; + } + + RefPtr<AudioChannelService> service = AudioChannelService::GetOrCreate(); + if (service && service->ProcessContentOrNormalChannelIsActive(ChildID())) { + return PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE; + } + + return mIsActivityOpener ? PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE + : PROCESS_PRIORITY_BACKGROUND; +} + +void +ParticularProcessPriorityManager::SetPriorityNow(ProcessPriority aPriority, + uint32_t aLRU) +{ + if (aPriority == PROCESS_PRIORITY_UNKNOWN) { + MOZ_ASSERT(false); + return; + } + + if (!ProcessPriorityManagerImpl::PrefsEnabled() || + !mContentParent || + mFrozen || + ((mPriority == aPriority) && (mLRU == aLRU))) { + return; + } + + if ((mPriority == aPriority) && (mLRU != aLRU)) { + mLRU = aLRU; + hal::SetProcessPriority(Pid(), mPriority, aLRU); + + nsPrintfCString processPriorityWithLRU("%s:%d", + ProcessPriorityToString(mPriority), aLRU); + + FireTestOnlyObserverNotification("process-priority-with-LRU-set", + processPriorityWithLRU.get()); + return; + } + + LOGP("Changing priority from %s to %s.", + ProcessPriorityToString(mPriority), + ProcessPriorityToString(aPriority)); + + ProcessPriority oldPriority = mPriority; + + mPriority = aPriority; + hal::SetProcessPriority(Pid(), mPriority); + + if (oldPriority != mPriority) { + ProcessPriorityManagerImpl::GetSingleton()-> + NotifyProcessPriorityChanged(this, oldPriority); + + Unused << mContentParent->SendNotifyProcessPriorityChanged(mPriority); + } + + FireTestOnlyObserverNotification("process-priority-set", + ProcessPriorityToString(mPriority)); +} + +void +ParticularProcessPriorityManager::Freeze() +{ + mFrozen = true; +} + +void +ParticularProcessPriorityManager::Unfreeze() +{ + mFrozen = false; +} + +void +ParticularProcessPriorityManager::ShutDown() +{ + MOZ_ASSERT(mContentParent); + + UnregisterWakeLockObserver(this); + + if (mResetPriorityTimer) { + mResetPriorityTimer->Cancel(); + mResetPriorityTimer = nullptr; + } + + mContentParent = nullptr; +} + +void +ProcessPriorityManagerImpl::FireTestOnlyObserverNotification( + const char* aTopic, + const nsACString& aData /* = EmptyCString() */) +{ + if (!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 (!ProcessPriorityManagerImpl::TestMode()) { + return; + } + + nsAutoCString data; + if (aData) { + data.AppendASCII(aData); + } + + FireTestOnlyObserverNotification(aTopic, data); +} + +void +ParticularProcessPriorityManager::FireTestOnlyObserverNotification( + const char* aTopic, + const nsACString& aData /* = EmptyCString() */) +{ + if (!ProcessPriorityManagerImpl::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_IsParentProcess()) { + 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_IsParentProcess()) { + 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; +} + +ProcessLRUPool::ProcessLRUPool(ProcessPriority aPriority) + : mPriority(aPriority) + , mLRUPoolLevels(1) +{ + // We set mLRUPoolLevels according to our pref. + // This value is used to set background process LRU pool + const char* str = ProcessPriorityToString(aPriority); + nsPrintfCString pref("dom.ipc.processPriorityManager.%s.LRUPoolLevels", str); + + Preferences::GetUint(pref.get(), &mLRUPoolLevels); + + // 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. + // Similarly we can have at most 4 background perceivable LRU levels. We + // should really be getting rid of oom_adj and just rely on oom_score_adj + // only which would lift this constraint. + MOZ_ASSERT(aPriority != PROCESS_PRIORITY_BACKGROUND || mLRUPoolLevels <= 6); + MOZ_ASSERT(aPriority != PROCESS_PRIORITY_BACKGROUND_PERCEIVABLE || + mLRUPoolLevels <= 4); + + // LRU pool size = 2 ^ (number of background LRU pool levels) - 1 + uint32_t LRUPoolSize = (1 << mLRUPoolLevels) - 1; + + LOG("Making %s LRU pool with size(%d)", str, LRUPoolSize); +} + +uint32_t +ProcessLRUPool::CalculateLRULevel(uint32_t aLRU) +{ + // This is used to compute the LRU adjustment for the specified LRU position. + // We use power-of-two groups with increasing adjustments that look like the + // following: + + // Priority : LRU0, LRU1 + // Priority+1: LRU2, LRU3 + // Priority+2: LRU4, LRU5, LRU6, LRU7 + // Priority+3: LRU8, LRU9, LRU10, LRU11, LRU12, LRU12, LRU13, LRU14, LRU15 + // ... + // Priority+L-1: 2^(number of LRU pool levels - 1) + // (End of buffer) + + int exp; + Unused << frexp(static_cast<double>(aLRU), &exp); + uint32_t level = std::max(exp - 1, 0); + + return std::min(mLRUPoolLevels - 1, level); +} + +void +ProcessLRUPool::Remove(ParticularProcessPriorityManager* aParticularManager) +{ + nsTArray<ParticularProcessPriorityManager*>::index_type index = + mLRUPool.IndexOf(aParticularManager); + + if (index == nsTArray<ParticularProcessPriorityManager*>::NoIndex) { + return; + } + + mLRUPool.RemoveElementAt(index); + AdjustLRUValues(index, /* removed */ true); + + LOG("Remove ChildID(%" PRIu64 ") from %s LRU pool", + static_cast<uint64_t>(aParticularManager->ChildID()), + ProcessPriorityToString(mPriority)); +} + +/* + * Adjust the LRU values of all the processes in an LRU pool. When true the + * `removed` parameter indicates that the processes were shifted left because + * an element was removed; otherwise it means the elements were shifted right + * as an element was added. + */ +void +ProcessLRUPool::AdjustLRUValues( + nsTArray<ParticularProcessPriorityManager*>::index_type aStart, + bool removed) +{ + uint32_t adj = (removed ? 2 : 1); + + for (nsTArray<ParticularProcessPriorityManager*>::index_type i = aStart; + i < mLRUPool.Length(); + i++) { + /* Check whether i is a power of two. If so, then it crossed a LRU group + * boundary and we need to assign its new process priority LRU. Note that + * depending on the direction and the bias this test will pick different + * elements. */ + if (((i + adj) & (i + adj - 1)) == 0) { + mLRUPool[i]->SetPriorityNow(mPriority, CalculateLRULevel(i + 1)); + } + } +} + +void +ProcessLRUPool::Add(ParticularProcessPriorityManager* aParticularManager) +{ + // Shift the list in the pool, so we have room at index 0 for the newly added + // manager + mLRUPool.InsertElementAt(0, aParticularManager); + AdjustLRUValues(1, /* removed */ false); + + LOG("Add ChildID(%" PRIu64 ") into %s LRU pool", + static_cast<uint64_t>(aParticularManager->ChildID()), + ProcessPriorityToString(mPriority)); +} + +} // namespace + +namespace mozilla { + +/* static */ void +ProcessPriorityManager::Init() +{ + ProcessPriorityManagerImpl::StaticInit(); + ProcessPriorityManagerChild::StaticInit(); + ParticularProcessPriorityManager::StaticInit(); +} + +/* static */ void +ProcessPriorityManager::SetProcessPriority(ContentParent* aContentParent, + ProcessPriority aPriority) +{ + MOZ_ASSERT(aContentParent); + + ProcessPriorityManagerImpl* singleton = + ProcessPriorityManagerImpl::GetSingleton(); + if (singleton) { + singleton->SetProcessPriority(aContentParent, aPriority); + } +} + +/* 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 |