diff -r 000000000000 -r 6474c204b198 xpcom/base/nsMemoryReporterManager.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/xpcom/base/nsMemoryReporterManager.h Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,230 @@ +/* -*- 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/. */ + +#ifndef nsMemoryReporterManager_h__ +#define nsMemoryReporterManager_h__ + +#include "nsIMemoryReporter.h" +#include "nsITimer.h" +#include "nsServiceManagerUtils.h" +#include "mozilla/Mutex.h" +#include "nsTHashtable.h" +#include "nsHashKeys.h" + +class nsITimer; + +namespace mozilla { +namespace dom { +class MemoryReport; +} +} + +class nsMemoryReporterManager : public nsIMemoryReporterManager +{ +public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIMEMORYREPORTERMANAGER + + nsMemoryReporterManager(); + virtual ~nsMemoryReporterManager(); + + // Gets the memory reporter manager service. + static nsMemoryReporterManager* GetOrCreate() + { + nsCOMPtr imgr = + do_GetService("@mozilla.org/memory-reporter-manager;1"); + return static_cast(imgr.get()); + } + + typedef nsTHashtable > StrongReportersTable; + typedef nsTHashtable > WeakReportersTable; + + void IncrementNumChildProcesses(); + void DecrementNumChildProcesses(); + + // Inter-process memory reporting proceeds as follows. + // + // - GetReports() (declared within NS_DECL_NSIMEMORYREPORTERMANAGER) + // synchronously gets memory reports for the current process, tells all + // child processes to get memory reports, and sets up some state + // (mGetReportsState) for when the child processes report back, including a + // timer. Control then returns to the main event loop. + // + // - HandleChildReports() is called (asynchronously) once per child process + // that reports back. If all child processes report back before time-out, + // the timer is cancelled. (The number of child processes is part of the + // saved request state.) + // + // - TimeoutCallback() is called (asynchronously) if all the child processes + // don't respond within the time threshold. + // + // - FinishReporting() finishes things off. It is *always* called -- either + // from HandleChildReports() (if all child processes have reported back) or + // from TimeoutCallback() (if time-out occurs). + // + // All operations occur on the main thread. + // + // The above sequence of steps is a "request". A partially-completed request + // is described as "in flight". + // + // Each request has a "generation", a unique number that identifies it. This + // is used to ensure that each reports from a child process corresponds to + // the appropriate request from the parent process. (It's easier to + // implement a generation system than to implement a child report request + // cancellation mechanism.) + // + // Failures are mostly ignored, because it's (a) typically the most sensible + // thing to do, and (b) often hard to do anything else. The following are + // the failure cases of note. + // + // - If a request is made while the previous request is in flight, the new + // request is ignored, as per getReports()'s specification. No error is + // reported, because the previous request will complete soon enough. + // + // - If one or more child processes fail to respond within the time limit, + // things will proceed as if they don't exist. No error is reported, + // because partial information is better than nothing. + // + // - If a child process reports after the time-out occurs, it is ignored. + // (Generation checking will ensure it is ignored even if a subsequent + // request is in flight; this is the main use of generations.) No error + // is reported, because there's nothing sensible to be done about it at + // this late stage. + // + // Now, what what happens if a child process is created/destroyed in the + // middle of a request? Well, GetReportsState contains a copy of + // mNumChildProcesses which it uses to determine finished-ness. So... + // + // - If a process is created, it won't have received the request for reports, + // and the GetReportsState's mNumChildProcesses won't account for it. So + // the reported data will reflect how things were when the request began. + // + // - If a process is destroyed before reporting back, we'll just hit the + // time-out, because we'll have received reports (barring other errors) + // from N-1 child process. So the reported data will reflect how things + // are when the request ends. + // + // - If a process is destroyed after reporting back, but before all other + // child processes have reported back, it will be included in the reported + // data. So the reported data will reflect how things were when the + // request began. + // + // The inconsistencies between these three cases are unfortunate but + // difficult to avoid. It's enough of an edge case to not be worth doing + // more. + // + void HandleChildReports( + const uint32_t& generation, + const InfallibleTArray& aChildReports); + nsresult FinishReporting(); + + // Functions that (a) implement distinguished amounts, and (b) are outside of + // this module. + struct AmountFns + { + mozilla::InfallibleAmountFn mJSMainRuntimeGCHeap; + mozilla::InfallibleAmountFn mJSMainRuntimeTemporaryPeak; + mozilla::InfallibleAmountFn mJSMainRuntimeCompartmentsSystem; + mozilla::InfallibleAmountFn mJSMainRuntimeCompartmentsUser; + + mozilla::InfallibleAmountFn mImagesContentUsedUncompressed; + + mozilla::InfallibleAmountFn mStorageSQLite; + + mozilla::InfallibleAmountFn mLowMemoryEventsVirtual; + mozilla::InfallibleAmountFn mLowMemoryEventsPhysical; + + mozilla::InfallibleAmountFn mGhostWindows; + + AmountFns() { mozilla::PodZero(this); } + }; + AmountFns mAmountFns; + + // Convenience function to get RSS easily from other code. This is useful + // when debugging transient memory spikes with printf instrumentation. + static int64_t ResidentFast(); + + // Functions that measure per-tab memory consumption. + struct SizeOfTabFns + { + mozilla::JSSizeOfTabFn mJS; + mozilla::NonJSSizeOfTabFn mNonJS; + + SizeOfTabFns() + { + mozilla::PodZero(this); + } + }; + SizeOfTabFns mSizeOfTabFns; + +private: + nsresult RegisterReporterHelper(nsIMemoryReporter* aReporter, + bool aForce, bool aStrongRef); + nsresult StartGettingReports(); + + static void TimeoutCallback(nsITimer* aTimer, void* aData); + // Note: this timeout needs to be long enough to allow for the + // possibility of DMD reports and/or running on a low-end phone. + static const uint32_t kTimeoutLengthMS = 50000; + + mozilla::Mutex mMutex; + bool mIsRegistrationBlocked; + + StrongReportersTable* mStrongReporters; + WeakReportersTable* mWeakReporters; + + // These two are only used for testing purposes. + StrongReportersTable* mSavedStrongReporters; + WeakReportersTable* mSavedWeakReporters; + + uint32_t mNumChildProcesses; + uint32_t mNextGeneration; + + struct GetReportsState + { + uint32_t mGeneration; + nsCOMPtr mTimer; + uint32_t mNumChildProcesses; + uint32_t mNumChildProcessesCompleted; + bool mParentDone; + nsCOMPtr mHandleReport; + nsCOMPtr mHandleReportData; + nsCOMPtr mFinishReporting; + nsCOMPtr mFinishReportingData; + nsString mDMDDumpIdent; + + GetReportsState(uint32_t aGeneration, nsITimer* aTimer, + uint32_t aNumChildProcesses, + nsIHandleReportCallback* aHandleReport, + nsISupports* aHandleReportData, + nsIFinishReportingCallback* aFinishReporting, + nsISupports* aFinishReportingData, + const nsAString &aDMDDumpIdent) + : mGeneration(aGeneration) + , mTimer(aTimer) + , mNumChildProcesses(aNumChildProcesses) + , mNumChildProcessesCompleted(0) + , mParentDone(false) + , mHandleReport(aHandleReport) + , mHandleReportData(aHandleReportData) + , mFinishReporting(aFinishReporting) + , mFinishReportingData(aFinishReportingData) + , mDMDDumpIdent(aDMDDumpIdent) + { + } + }; + + // When this is non-null, a request is in flight. Note: We use manual + // new/delete for this because its lifetime doesn't match block scope or + // anything like that. + GetReportsState* mGetReportsState; +}; + +#define NS_MEMORY_REPORTER_MANAGER_CID \ +{ 0xfb97e4f5, 0x32dd, 0x497a, \ +{ 0xba, 0xa2, 0x7d, 0x1e, 0x55, 0x7, 0x99, 0x10 } } + +#endif // nsMemoryReporterManager_h__