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

Backed out 3 changesets (bug 913260)

Browse Source 
CLOSED TREE

Backed out changeset 9195be8a50cb (bug 913260)
Backed out changeset 09c71a3e7b85 (bug 913260)
Backed out changeset 8a8691a26012 (bug 913260)
This commit is contained in:
Phil Ringnalda 2013-09-24 20:31:00 -07:00
parent e442bb5b9f
commit 12216d4f00
14 changed files with 480 additions and 656 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

187
dom/base/nsWindowMemoryReporter.cpp
View File

@ -9,10 +9,8 @@
#include "nsGlobalWindow.h"
#include "nsIDocument.h"
#include "nsIEffectiveTLDService.h"
#include "mozilla/ClearOnShutdown.h"
#include "mozilla/Preferences.h"
#include "mozilla/Services.h"
#include "mozilla/StaticPtr.h"
#include "mozilla/Preferences.h"
#include "nsNetCID.h"
#include "nsPrintfCString.h"
#include "XPCJSMemoryReporter.h"
@ -21,8 +19,6 @@
using namespace mozilla;
StaticRefPtr<nsWindowMemoryReporter> sWindowReporter;
nsWindowMemoryReporter::nsWindowMemoryReporter()
: mCheckForGhostWindowsCallbackPending(false)
{
@ -35,23 +31,27 @@ NS_IMPL_ISUPPORTS3(nsWindowMemoryReporter, nsIMemoryReporter, nsIObserver,
void
nsWindowMemoryReporter::Init()
{
MOZ_ASSERT(!sWindowReporter);
sWindowReporter = new nsWindowMemoryReporter();
ClearOnShutdown(&sWindowReporter);
NS_RegisterMemoryReporter(sWindowReporter);
// The memory reporter manager will own this object.
nsRefPtr<nsWindowMemoryReporter> windowReporter = new nsWindowMemoryReporter();
NS_RegisterMemoryReporter(windowReporter);
nsCOMPtr<nsIObserverService> os = services::GetObserverService();
if (os) {
// DOM_WINDOW_DESTROYED_TOPIC announces what we call window "detachment",
// when a window's docshell is set to NULL.
os->AddObserver(sWindowReporter, DOM_WINDOW_DESTROYED_TOPIC,
os->AddObserver(windowReporter, DOM_WINDOW_DESTROYED_TOPIC,
/* weakRef = */ true);
os->AddObserver(sWindowReporter, "after-minimize-memory-usage",
os->AddObserver(windowReporter, "after-minimize-memory-usage",
/* weakRef = */ true);
}
NS_RegisterMemoryReporter(new GhostWindowsReporter());
RegisterGhostWindowsDistinguishedAmount(GhostWindowsReporter::DistinguishedAmount);
nsRefPtr<GhostURLsReporter> ghostURLsReporter =
new GhostURLsReporter(windowReporter);
NS_RegisterMemoryReporter(ghostURLsReporter);
nsRefPtr<NumGhostsReporter> numGhostsReporter =
new NumGhostsReporter(windowReporter);
NS_RegisterMemoryReporter(numGhostsReporter);
}
static already_AddRefed<nsIURI>
@ -311,52 +311,6 @@ GetWindows(const uint64_t& aId, nsGlobalWindow*& aWindow, void* aClosure)
return PL_DHASH_NEXT;
}
struct ReportGhostWindowsEnumeratorData
{
nsIMemoryReporterCallback* callback;
nsISupports* closure;
nsresult rv;
};
static PLDHashOperator
ReportGhostWindowsEnumerator(nsUint64HashKey* aIDHashKey, void* aClosure)
{
ReportGhostWindowsEnumeratorData *data =
static_cast<ReportGhostWindowsEnumeratorData*>(aClosure);
nsGlobalWindow::WindowByIdTable* windowsById =
nsGlobalWindow::GetWindowsTable();
if (!windowsById) {
NS_WARNING("Couldn't get window-by-id hashtable?");
return PL_DHASH_NEXT;
}
nsGlobalWindow* window = windowsById->Get(aIDHashKey->GetKey());
if (!window) {
NS_WARNING("Could not look up window?");
return PL_DHASH_NEXT;
}
nsAutoCString path;
path.AppendLiteral("ghost-windows/");
AppendWindowURI(window, path);
nsresult rv = data->callback->Callback(
/* process = */ EmptyCString(),
path,
nsIMemoryReporter::KIND_OTHER,
nsIMemoryReporter::UNITS_COUNT,
/* amount = */ 1,
/* description = */ NS_LITERAL_CSTRING("A ghost window."),
data->closure);
if (NS_FAILED(rv) && NS_SUCCEEDED(data->rv)) {
data->rv = rv;
}
return PL_DHASH_NEXT;
}
NS_IMETHODIMP
nsWindowMemoryReporter::GetName(nsACString &aName)
{
@ -377,18 +331,12 @@ nsWindowMemoryReporter::CollectReports(nsIMemoryReporterCallback* aCb,
WindowArray windows;
windowsById->Enumerate(GetWindows, &windows);
// Get the IDs of all the "ghost" windows, and call aCb->Callback() for each
// one.
// Get the IDs of all the "ghost" windows.
nsTHashtable<nsUint64HashKey> ghostWindows;
CheckForGhostWindows(&ghostWindows);
ReportGhostWindowsEnumeratorData reportGhostWindowsEnumData =
{ aCb, aClosure, NS_OK };
ghostWindows.EnumerateEntries(ReportGhostWindowsEnumerator,
&reportGhostWindowsEnumData);
nsresult rv = reportGhostWindowsEnumData.rv;
NS_ENSURE_SUCCESS(rv, rv);
WindowPaths windowPaths;
WindowPaths topWindowPaths;
// Collect window memory usage.
@ -396,17 +344,17 @@ nsWindowMemoryReporter::CollectReports(nsIMemoryReporterCallback* aCb,
nsCOMPtr<amIAddonManager> addonManager =
do_GetService("@mozilla.org/addons/integration;1");
for (uint32_t i = 0; i < windows.Length(); i++) {
rv = CollectWindowReports(windows[i], addonManager,
&windowTotalSizes, &ghostWindows,
&windowPaths, &topWindowPaths, aCb,
aClosure);
nsresult rv = CollectWindowReports(windows[i], addonManager,
&windowTotalSizes, &ghostWindows,
&windowPaths, &topWindowPaths, aCb,
aClosure);
NS_ENSURE_SUCCESS(rv, rv);
}
// Report JS memory usage. We do this from here because the JS memory
// reporter needs to be passed |windowPaths|.
rv = xpc::JSReporter::CollectReports(&windowPaths, &topWindowPaths,
aCb, aClosure);
nsresult rv = xpc::JSReporter::CollectReports(&windowPaths, &topWindowPaths,
aCb, aClosure);
NS_ENSURE_SUCCESS(rv, rv);
#define REPORT(_path, _amount, _desc) \
@ -714,11 +662,94 @@ nsWindowMemoryReporter::CheckForGhostWindows(
&ghostEnumData);
}
/* static */ int64_t
nsWindowMemoryReporter::GhostWindowsReporter::DistinguishedAmount()
NS_IMPL_ISUPPORTS1(nsWindowMemoryReporter::GhostURLsReporter,
nsIMemoryReporter)
nsWindowMemoryReporter::
GhostURLsReporter::GhostURLsReporter(
nsWindowMemoryReporter* aWindowReporter)
: mWindowReporter(aWindowReporter)
{
nsTHashtable<nsUint64HashKey> ghostWindows;
sWindowReporter->CheckForGhostWindows(&ghostWindows);
return ghostWindows.Count();
}
NS_IMETHODIMP
nsWindowMemoryReporter::
GhostURLsReporter::GetName(nsACString& aName)
{
aName.AssignLiteral("ghost-windows-multi");
return NS_OK;
}
struct ReportGhostWindowsEnumeratorData
{
nsIMemoryReporterCallback* callback;
nsISupports* closure;
nsresult rv;
};
static PLDHashOperator
ReportGhostWindowsEnumerator(nsUint64HashKey* aIDHashKey, void* aClosure)
{
ReportGhostWindowsEnumeratorData *data =
static_cast<ReportGhostWindowsEnumeratorData*>(aClosure);
nsGlobalWindow::WindowByIdTable* windowsById =
nsGlobalWindow::GetWindowsTable();
if (!windowsById) {
NS_WARNING("Couldn't get window-by-id hashtable?");
return PL_DHASH_NEXT;
}
nsGlobalWindow* window = windowsById->Get(aIDHashKey->GetKey());
if (!window) {
NS_WARNING("Could not look up window?");
return PL_DHASH_NEXT;
}
nsAutoCString path;
path.AppendLiteral("ghost-windows/");
AppendWindowURI(window, path);
nsresult rv = data->callback->Callback(
/* process = */ EmptyCString(),
path,
nsIMemoryReporter::KIND_OTHER,
nsIMemoryReporter::UNITS_COUNT,
/* amount = */ 1,
/* description = */ NS_LITERAL_CSTRING("A ghost window."),
data->closure);
if (NS_FAILED(rv) && NS_SUCCEEDED(data->rv)) {
data->rv = rv;
}
return PL_DHASH_NEXT;
}
NS_IMETHODIMP
nsWindowMemoryReporter::
GhostURLsReporter::CollectReports(
nsIMemoryReporterCallback* aCb,
nsISupports* aClosure)
{
// Get the IDs of all the ghost windows in existance.
nsTHashtable<nsUint64HashKey> ghostWindows;
mWindowReporter->CheckForGhostWindows(&ghostWindows);
ReportGhostWindowsEnumeratorData reportGhostWindowsEnumData =
{ aCb, aClosure, NS_OK };
// Call aCb->Callback() for each ghost window.
ghostWindows.EnumerateEntries(ReportGhostWindowsEnumerator,
&reportGhostWindowsEnumData);
return reportGhostWindowsEnumData.rv;
}
int64_t
nsWindowMemoryReporter::NumGhostsReporter::Amount()
{
nsTHashtable<nsUint64HashKey> ghostWindows;
mWindowReporter->CheckForGhostWindows(&ghostWindows);
return ghostWindows.Count();
}

28
dom/base/nsWindowMemoryReporter.h
View File

@ -120,14 +120,31 @@ public:
static void Init();
private:
/**
* GhostURLsReporter generates the list of all ghost windows' URLs. If
* you're only interested in this list, running this report is faster than
* running nsWindowMemoryReporter.
*/
class GhostURLsReporter MOZ_FINAL : public nsIMemoryReporter
{
public:
GhostURLsReporter(nsWindowMemoryReporter* aWindowReporter);
NS_DECL_ISUPPORTS
NS_DECL_NSIMEMORYREPORTER
private:
nsRefPtr<nsWindowMemoryReporter> mWindowReporter;
};
/**
* nsGhostWindowReporter generates the "ghost-windows" report, which counts
* the number of ghost windows present.
*/
class GhostWindowsReporter MOZ_FINAL : public mozilla::MemoryUniReporter
class NumGhostsReporter MOZ_FINAL : public mozilla::MemoryUniReporter
{
public:
GhostWindowsReporter()
NumGhostsReporter(nsWindowMemoryReporter* aWindowReporter)
: MemoryUniReporter("ghost-windows", KIND_OTHER, UNITS_COUNT,
"The number of ghost windows present (the number of nodes underneath "
"explicit/window-objects/top(none)/ghost, modulo race conditions). A ghost "
@ -137,12 +154,13 @@ private:
"about:memory's minimize memory usage button.\n\n"
"Ghost windows can happen legitimately, but they are often indicative of "
"leaks in the browser or add-ons.")
, mWindowReporter(aWindowReporter)
{}
static int64_t DistinguishedAmount();
private:
int64_t Amount() MOZ_OVERRIDE { return DistinguishedAmount(); }
int64_t Amount() MOZ_OVERRIDE;
nsRefPtr<nsWindowMemoryReporter> mWindowReporter;
};
// Protect ctor, use Init() instead.

24
image/src/imgLoader.cpp
View File

@ -137,7 +137,7 @@ public:
return NS_OK;
}
static int64_t ImagesContentUsedUncompressedDistinguishedAmount()
static int64_t GetImagesContentUsedUncompressed()
{
size_t n = 0;
for (uint32_t i = 0; i < imgLoader::sMemReporter->mKnownLoaders.Length(); i++) {
@ -223,6 +223,26 @@ private:
NS_IMPL_ISUPPORTS1(imgMemoryReporter, nsIMemoryReporter)
// This is used by telemetry.
class ImagesContentUsedUncompressedReporter MOZ_FINAL
: public MemoryUniReporter
{
public:
ImagesContentUsedUncompressedReporter()
: MemoryUniReporter("images-content-used-uncompressed",
KIND_OTHER, UNITS_BYTES,
"This is the sum of the 'explicit/images/content/used/uncompressed-heap' "
"and 'explicit/images/content/used/uncompressed-nonheap' numbers. However, "
"it is measured at a different time and so may give slightly different "
"results.")
{}
private:
int64_t Amount() MOZ_OVERRIDE
{
return imgMemoryReporter::GetImagesContentUsedUncompressed();
}
};
NS_IMPL_ISUPPORTS3(nsProgressNotificationProxy,
nsIProgressEventSink,
nsIChannelEventSink,
@ -819,7 +839,7 @@ void imgLoader::GlobalInit()
sMemReporter = new imgMemoryReporter();
NS_RegisterMemoryReporter(sMemReporter);
RegisterImagesContentUsedUncompressedDistinguishedAmount(imgMemoryReporter::ImagesContentUsedUncompressedDistinguishedAmount);
NS_RegisterMemoryReporter(new ImagesContentUsedUncompressedReporter());
}
nsresult imgLoader::InitCache()

91
js/xpconnect/src/XPCJSRuntime.cpp
View File

@ -1575,35 +1575,67 @@ GetCompartmentName(JSCompartment *c, nsCString &name, bool replaceSlashes)
}
}
static int64_t
JSMainRuntimeGCHeapDistinguishedAmount()
// Telemetry relies on this being a uni-reporter (rather than part of the "js"
// reporter).
class JSMainRuntimeGCHeapReporter MOZ_FINAL : public MemoryUniReporter
{
JSRuntime *rt = nsXPConnect::GetRuntimeInstance()->Runtime();
return int64_t(JS_GetGCParameter(rt, JSGC_TOTAL_CHUNKS)) *
js::gc::ChunkSize;
}
public:
JSMainRuntimeGCHeapReporter()
: MemoryUniReporter("js-main-runtime-gc-heap", KIND_OTHER, UNITS_BYTES,
"Memory used by the garbage-collected heap in the main JSRuntime.")
{}
private:
int64_t Amount() MOZ_OVERRIDE
{
JSRuntime *rt = nsXPConnect::GetRuntimeInstance()->Runtime();
return int64_t(JS_GetGCParameter(rt, JSGC_TOTAL_CHUNKS)) *
js::gc::ChunkSize;
}
};
static int64_t
JSMainRuntimeTemporaryPeakDistinguishedAmount()
// Nb: js-main-runtime-compartments/system + js-main-runtime-compartments/user
// could be different to the number of compartments reported by JSReporter if a
// garbage collection occurred between them being consulted. We could move
// these reporters into JSReporter to avoid that problem, but then we couldn't
// easily report them via telemetry, so we live with the small risk of
// inconsistencies.
class RedundantJSMainRuntimeCompartmentsSystemReporter MOZ_FINAL : public MemoryUniReporter
{
JSRuntime *rt = nsXPConnect::GetRuntimeInstance()->Runtime();
return JS::PeakSizeOfTemporary(rt);
}
public:
// An empty description is ok because this is a "redundant/"-prefixed
// reporter and so is ignored by about:memory.
RedundantJSMainRuntimeCompartmentsSystemReporter()
: MemoryUniReporter("redundant/js-main-runtime-compartments/system",
KIND_OTHER, UNITS_COUNT, "")
{}
private:
int64_t Amount() MOZ_OVERRIDE
{
JSRuntime *rt = nsXPConnect::GetRuntimeInstance()->Runtime();
return JS::SystemCompartmentCount(rt);
}
};
static int64_t
JSMainRuntimeCompartmentsSystemDistinguishedAmount()
class RedundantJSMainRuntimeCompartmentsUserReporter MOZ_FINAL : public MemoryUniReporter
{
JSRuntime *rt = nsXPConnect::GetRuntimeInstance()->Runtime();
return JS::SystemCompartmentCount(rt);
}
static int64_t
JSMainRuntimeCompartmentsUserDistinguishedAmount()
{
JSRuntime *rt = nsXPConnect::GetRuntimeInstance()->Runtime();
return JS::UserCompartmentCount(rt);
}
public:
// An empty description is ok because this is a "redundant/"-prefixed
// reporter and so is ignored by about:memory.
RedundantJSMainRuntimeCompartmentsUserReporter()
: MemoryUniReporter("redundant/js-main-runtime-compartments/user",
KIND_OTHER, UNITS_COUNT,
"The number of JavaScript compartments for user code in the main JSRuntime.")
{}
private:
int64_t Amount() MOZ_OVERRIDE
{
JSRuntime *rt = nsXPConnect::GetRuntimeInstance()->Runtime();
return JS::UserCompartmentCount(rt);
}
};
// This is also a single reporter so it can be used by telemetry.
class JSMainRuntimeTemporaryPeakReporter MOZ_FINAL : public MemoryUniReporter
{
public:
@ -1616,7 +1648,8 @@ public:
private:
int64_t Amount() MOZ_OVERRIDE
{
return JSMainRuntimeTemporaryPeakDistinguishedAmount();
JSRuntime *rt = nsXPConnect::GetRuntimeInstance()->Runtime();
return JS::PeakSizeOfTemporary(rt);
}
};
@ -3023,13 +3056,11 @@ XPCJSRuntime::XPCJSRuntime(nsXPConnect* aXPConnect)
if (!xpc_LocalizeRuntime(runtime))
NS_RUNTIMEABORT("xpc_LocalizeRuntime failed.");
// Register memory reporters and distinguished amount functions.
NS_RegisterMemoryReporter(new JSMainRuntimeCompartmentsReporter);
NS_RegisterMemoryReporter(new JSMainRuntimeGCHeapReporter());
NS_RegisterMemoryReporter(new RedundantJSMainRuntimeCompartmentsSystemReporter());
NS_RegisterMemoryReporter(new RedundantJSMainRuntimeCompartmentsUserReporter());
NS_RegisterMemoryReporter(new JSMainRuntimeTemporaryPeakReporter());
RegisterJSMainRuntimeGCHeapDistinguishedAmount(JSMainRuntimeGCHeapDistinguishedAmount);
RegisterJSMainRuntimeTemporaryPeakDistinguishedAmount(JSMainRuntimeTemporaryPeakDistinguishedAmount);
RegisterJSMainRuntimeCompartmentsSystemDistinguishedAmount(JSMainRuntimeCompartmentsSystemDistinguishedAmount);
RegisterJSMainRuntimeCompartmentsUserDistinguishedAmount(JSMainRuntimeCompartmentsUserDistinguishedAmount);
NS_RegisterMemoryReporter(new JSMainRuntimeCompartmentsReporter);
// Install a JavaScript 'debugger' keyword handler in debug builds only
#ifdef DEBUG

39
storage/src/mozStorageService.cpp
View File

@ -53,13 +53,22 @@ namespace storage {
////////////////////////////////////////////////////////////////////////////////
//// Memory Reporting
static int64_t
StorageSQLiteDistinguishedAmount()
// We don't need an "explicit" reporter for total SQLite memory usage, because
// the multi-reporter provides reports that add up to the total. But it's
// useful to have the total in the "Other Measurements" list in about:memory,
// and more importantly, we also gather the total via telemetry.
class StorageSQLiteUniReporter MOZ_FINAL : public MemoryUniReporter
{
return ::sqlite3_memory_used();
}
public:
StorageSQLiteUniReporter()
: MemoryUniReporter("storage-sqlite", KIND_OTHER, UNITS_BYTES,
"Memory used by SQLite.")
{}
private:
int64_t Amount() MOZ_OVERRIDE { return ::sqlite3_memory_used(); }
};
class StorageSQLiteReporter MOZ_FINAL : public nsIMemoryReporter
class StorageSQLiteMultiReporter MOZ_FINAL : public nsIMemoryReporter
{
private:
Service *mService; // a weakref because Service contains a strongref to this
@ -70,7 +79,7 @@ private:
public:
NS_DECL_THREADSAFE_ISUPPORTS
StorageSQLiteReporter(Service *aService)
StorageSQLiteMultiReporter(Service *aService)
: mService(aService)
{
mStmtDesc = NS_LITERAL_CSTRING(
@ -205,7 +214,7 @@ private:
};
NS_IMPL_ISUPPORTS1(
StorageSQLiteReporter,
StorageSQLiteMultiReporter,
nsIMemoryReporter
)
@ -298,8 +307,8 @@ Service::Service()
Service::~Service()
{
(void)::NS_UnregisterMemoryReporter(mStorageSQLiteReporter);
mozilla::UnregisterStorageSQLiteDistinguishedAmount();
(void)::NS_UnregisterMemoryReporter(mStorageSQLiteUniReporter);
(void)::NS_UnregisterMemoryReporter(mStorageSQLiteMultiReporter);
int rc = sqlite3_vfs_unregister(mSqliteVFS);
if (rc != SQLITE_OK)
@ -529,12 +538,12 @@ Service::initialize()
sDefaultPageSize =
Preferences::GetInt(PREF_TS_PAGESIZE, PREF_TS_PAGESIZE_DEFAULT);
// Create and register our SQLite memory reporter and distinguished amount
// function. Registration can only happen on the main thread (otherwise
// you'll get cryptic crashes).
mStorageSQLiteReporter = new StorageSQLiteReporter(this);
(void)::NS_RegisterMemoryReporter(mStorageSQLiteReporter);
mozilla::RegisterStorageSQLiteDistinguishedAmount(StorageSQLiteDistinguishedAmount);
// Create and register our SQLite memory reporters. Registration can only
// happen on the main thread (otherwise you'll get cryptic crashes).
mStorageSQLiteUniReporter = new StorageSQLiteUniReporter();
mStorageSQLiteMultiReporter = new StorageSQLiteMultiReporter(this);
(void)::NS_RegisterMemoryReporter(mStorageSQLiteUniReporter);
(void)::NS_RegisterMemoryReporter(mStorageSQLiteMultiReporter);
return NS_OK;
}

3
storage/src/mozStorageService.h
View File

@ -172,7 +172,8 @@ private:
nsCOMPtr<nsIFile> mProfileStorageFile;
nsCOMPtr<nsIMemoryReporter> mStorageSQLiteReporter;
nsCOMPtr<nsIMemoryReporter> mStorageSQLiteUniReporter;
nsCOMPtr<nsIMemoryReporter> mStorageSQLiteMultiReporter;
static Service *gService;

59
toolkit/components/aboutmemory/content/aboutMemory.js
View File

@ -131,21 +131,32 @@ function onUnload()
/**
* Iterates over each reporter.
*
* @param aIgnoreReporter
* Function that indicates if we should skip an entire reporter, based
* on its name.
* @param aIgnoreReport
* Function that indicates if we should skip a single report from a
* reporter, based on its path.
* @param aHandleReport
* The function that's called for each non-skipped report.
*/
function processMemoryReporters(aHandleReport)
function processMemoryReporters(aIgnoreReporter, aIgnoreReport, aHandleReport)
{
let handleReport = function(aProcess, aUnsafePath, aKind, aUnits,
aAmount, aDescription) {
aHandleReport(aProcess, aUnsafePath, aKind, aUnits, aAmount,
aDescription, /* presence = */ undefined);
if (!aIgnoreReport(aUnsafePath)) {
aHandleReport(aProcess, aUnsafePath, aKind, aUnits, aAmount,
aDescription, /* presence = */ undefined);
}
}
let e = gMgr.enumerateReporters();
while (e.hasMoreElements()) {
let mr = e.getNext().QueryInterface(Ci.nsIMemoryReporter);
mr.collectReports(handleReport, null);
if (!aIgnoreReporter(mr.name)) {
// |collectReports| never passes in a |presence| argument.
mr.collectReports(handleReport, null);
}
}
}
@ -154,17 +165,22 @@ function processMemoryReporters(aHandleReport)
*
* @param aReports
* Array of reports, read from a file or the clipboard.
* @param aIgnoreReport
* Function that indicates if we should skip a single report, based
* on its path.
* @param aHandleReport
* The function that's called for each report.
*/
function processMemoryReportsFromFile(aReports, aHandleReport)
function processMemoryReportsFromFile(aReports, aIgnoreReport, aHandleReport)
{
// Process each memory reporter with aHandleReport.
for (let i = 0; i < aReports.length; i++) {
let r = aReports[i];
aHandleReport(r.process, r.path, r.kind, r.units, r.amount,
r.description, r._presence);
if (!aIgnoreReport(r.path)) {
aHandleReport(r.process, r.path, r.kind, r.units, r.amount,
r.description, r._presence);
}
}
}
@ -183,6 +199,7 @@ let gVerbose;
// Values for the second argument to updateMainAndFooter.
let HIDE_FOOTER = 0;
let SHOW_FOOTER = 1;
let IGNORE_FOOTER = 2;
function updateMainAndFooter(aMsg, aFooterAction, aClassName)
{
@ -209,6 +226,7 @@ function updateMainAndFooter(aMsg, aFooterAction, aClassName)
switch (aFooterAction) {
case HIDE_FOOTER: gFooter.classList.add('hidden'); break;
case SHOW_FOOTER: gFooter.classList.remove('hidden'); break;
case IGNORE_FOOTER: break;
default: assertInput(false, "bad footer action in updateMainAndFooter");
}
}
@ -486,8 +504,8 @@ function updateAboutMemoryFromJSONObject(aObj)
"missing 'hasMozMallocUsableSize' property");
assertInput(aObj.reports && aObj.reports instanceof Array,
"missing or non-array 'reports' property");
let process = function(aHandleReport) {
processMemoryReportsFromFile(aObj.reports, aHandleReport);
let process = function(aIgnoreReporter, aIgnoreReport, aHandleReport) {
processMemoryReportsFromFile(aObj.reports, aIgnoreReport, aHandleReport);
}
appendAboutMemoryMain(process, aObj.hasMozMallocUsableSize);
} catch (ex) {
@ -919,6 +937,19 @@ function getPCollsByProcess(aProcessReports)
// be in parentheses, so a ')' might appear after the '.'.)
const gSentenceRegExp = /^[A-Z].*\.\)?$/m;
// Ignore any "redundant/"-prefixed reporters and reports, which are only
// used by telemetry.
function ignoreReporter(aName)
{
return aName.startsWith("redundant/");
}
function ignoreReport(aUnsafePath)
{
return aUnsafePath.startsWith("redundant/");
}
function handleReport(aProcess, aUnsafePath, aKind, aUnits, aAmount,
aDescription, aPresence)
{
@ -957,8 +988,7 @@ function getPCollsByProcess(aProcessReports)
assert(aPresence === undefined ||
aPresence == DReport.PRESENT_IN_FIRST_ONLY ||
aPresence == DReport.PRESENT_IN_SECOND_ONLY,
"bad presence");
aPresence == DReport.PRESENT_IN_SECOND_ONLY);
let process = aProcess === "" ? gUnnamedProcessStr : aProcess;
let unsafeNames = aUnsafePath.split('/');
@ -1016,7 +1046,7 @@ function getPCollsByProcess(aProcessReports)
}
}
aProcessReports(handleReport);
aProcessReports(ignoreReporter, ignoreReport, handleReport);
return pcollsByProcess;
}
@ -1342,11 +1372,6 @@ function appendProcessAboutMemoryElements(aP, aProcess, aTrees, aDegenerates,
let t = aTrees[treeName];
if (t) {
fillInTree(t);
// Using the "heap-allocated" reporter here instead of
// nsMemoryReporterManager.heapAllocated goes against the usual pattern.
// But the "heap-allocated" node will go in the tree like the others, so
// we have to deal with it, and once we're dealing with it, it's easier
// to keep doing so rather than switching to the distinguished amount.
hasKnownHeapAllocated =
aDegenerates &&
addHeapUnclassifiedNode(t, aDegenerates["heap-allocated"], aHeapTotal);

9
toolkit/components/aboutmemory/tests/test_aboutmemory.xul
View File

@ -150,6 +150,14 @@
// the largest). Processes without a |resident| memory reporter are saved
// for the end.
let fakeReporters2 = [
{ name: "redundant/foobar",
collectReports: function(aCbObj, aClosure) {
// Shouldn't reach here; aboutMemory.js should skip the reporter.
// (Nb: this must come after |mgr.explicit| is accessed, otherwise it
// *will* be run by nsMemoryReporterManager::GetExplicit()).
ok(false, "'redundant/foobar' reporter was run");
}
},
{ name: "fake3",
collectReports: function(aCbObj, aClosure) {
function f(aP1, aP2, aK, aU, aA) {
@ -166,6 +174,7 @@
HEAP, BYTES,200 * MB);
f("2nd", "other0", OTHER, BYTES,666 * MB);
f("2nd", "other1", OTHER, BYTES,111 * MB);
f("2nd", "redundant/blah", NONHEAP, BYTES,24*4*KB); // ignored!
// Check that we can handle "heap-allocated" not being present.
f("3rd", "explicit/a/b", HEAP, BYTES,333 * MB);

87
toolkit/components/aboutmemory/tests/test_memoryReporters.xul
View File

@ -45,7 +45,16 @@
let heapAllocatedAmounts = [];
let storageSqliteAmounts = [];
let present = {}
let areJsNonWindowCompartmentsPresent = false;
let areWindowObjectsJsCompartmentsPresent = false;
let isSandboxLocationShown = false;
let isPlacesPresent = false;
let isImagesPresent = false;
let isXptiWorkingSetPresent = false;
let isAtomTablePresent = false;
let isBigStringPresent = false;
let isSmallString1Present = false;
let isSmallString2Present = false;
// Generate a long, random string. We'll check that this string is
// reported in at least one of the memory reporters.
@ -83,36 +92,35 @@
// Check the presence of some other notable reporters.
} else if (aPath.search(/^explicit\/js-non-window\/.*compartment\(/) >= 0) {
present.jsNonWindowCompartments = true;
areJsNonWindowCompartmentsPresent = true;
} else if (aPath.search(/^explicit\/window-objects\/top\(.*\/js-compartment\(/) >= 0) {
present.windowObjectsJsCompartments = true;
areWindowObjectsJsCompartmentsPresent = true;
} else if (aPath.search(/^explicit\/storage\/sqlite\/places.sqlite/) >= 0) {
present.places = true;
isPlacesPresent = true;
} else if (aPath.search(/^explicit\/images/) >= 0) {
present.images = true;
isImagesPresent = true;
} else if (aPath.search(/^explicit\/xpti-working-set$/) >= 0) {
present.xptiWorkingSet = true;
isXptiWorkingSetPresent = true;
} else if (aPath.search(/^explicit\/atom-tables$/) >= 0) {
present.atomTable = true;
isAtomTablePresent = true;
} else if (/\[System Principal\].*this-is-a-sandbox-name/.test(aPath)) {
// A system compartment with a location (such as a sandbox) should
// show that location.
present.sandboxLocation = true;
isSandboxLocationShown = true;
} else if (aPath.contains(bigStringPrefix)) {
present.bigString = true;
isBigStringPresent = true;
} else if (aPath.contains("!)(*&")) {
present.smallString1 = true;
isSmallString1Present = true;
} else if (aPath.contains("@)(*&")) {
present.smallString2 = true;
isSmallString2Present = true;
}
}
let mgr = Cc["@mozilla.org/memory-reporter-manager;1"].
getService(Ci.nsIMemoryReporterManager);
// Access the distinguished amounts (mgr.explicit et al.) just to make sure
// they don't crash. We can't check their actual values because they're
// non-deterministic.
// Access mgr.explicit and mgr.resident just to make sure they don't crash.
// We can't check their actual values because they're non-deterministic.
//
// Nb: mgr.explicit will throw NS_ERROR_NOT_AVAILABLE if this is a
// --enable-trace-malloc build. Allow for that exception, but *only* that
@ -125,35 +133,7 @@
is(ex.result, Cr.NS_ERROR_NOT_AVAILABLE, "mgr.explicit exception");
haveExplicit = false;
}
let amounts = [
"vsize",
"resident",
"residentFast",
"heapAllocated",
"heapOverheadRatio",
"JSMainRuntimeGCHeap",
"JSMainRuntimeTemporaryPeak",
"JSMainRuntimeCompartmentsSystem",
"JSMainRuntimeCompartmentsUser",
"imagesContentUsedUncompressed",
"storageSQLite",
"lowMemoryEventsVirtual",
"lowMemoryEventsPhysical",
"ghostWindows",
"pageFaultsHard",
];
for (let i = 0; i < amounts.length; i++) {
try {
// If mgr[amounts[i]] throws an exception, just move on -- some amounts
// aren't available on all platforms. But if the attribute simply
// isn't present, that indicates the distinguished amounts have changed
// and this file hasn't been updated appropriately.
dummy = mgr[amounts[i]];
ok(dummy !== undefined,
"accessed an unknown distinguished amount: " + amounts[i]);
} catch (ex) {
}
}
dummy = mgr.resident;
let e = mgr.enumerateReporters();
while (e.hasMoreElements()) {
@ -180,17 +160,18 @@
checkSpecialReport("vsize", vsizeAmounts);
checkSpecialReport("resident", residentAmounts);
checkSpecialReport("js-main-runtime-gc-heap-committed/used/gc-things", jsGcHeapAmounts);
checkSpecialReport("storage-sqlite", storageSqliteAmounts);
ok(present.jsNonWindowCompartments, "js-non-window compartments are present");
ok(present.windowObjectsJsCompartments, "window-objects/.../js compartments are present");
ok(present.places, "places is present");
ok(present.images, "images is present");
ok(present.xptiWorkingSet, "xpti-working-set is present");
ok(present.atomTable, "atom-table is present");
ok(present.sandboxLocation, "sandbox locations are present");
ok(present.bigString, "large string is present");
ok(present.smallString1, "small string 1 is present");
ok(present.smallString2, "small string 2 is present");
ok(areJsNonWindowCompartmentsPresent, "js-non-window compartments are present");
ok(areWindowObjectsJsCompartmentsPresent, "window-objects/.../js compartments are present");
ok(isSandboxLocationShown, "sandbox locations are present");
ok(isPlacesPresent, "places is present");
ok(isImagesPresent, "images is present");
ok(isXptiWorkingSetPresent, "xpti-working-set is present");
ok(isAtomTablePresent, "atom-table is present");
ok(isBigStringPresent, "large string is present");
ok(isSmallString1Present, "small string 1 is present");
ok(isSmallString2Present, "small string 2 is present");
]]>
</script>

111
toolkit/components/telemetry/TelemetryPing.js
View File

@ -39,6 +39,39 @@ const TELEMETRY_INTERVAL = 60000;
// Delay before intializing telemetry (ms)
const TELEMETRY_DELAY = 60000;
// MEM_HISTOGRAMS lists the memory reporters we turn into histograms.
//
// Note that we currently handle only vanilla memory reporters, not memory
// multi-reporters.
//
// test_TelemetryPing.js relies on some of these memory reporters
// being here. If you remove any of the following histograms from
// MEM_HISTOGRAMS, you'll have to modify test_TelemetryPing.js:
//
// * MEMORY_JS_GC_HEAP, and
// * MEMORY_JS_COMPARTMENTS_SYSTEM.
//
// We used to measure "explicit" too, but it could cause hangs, and the data
// was always really noisy anyway. See bug 859657.
const MEM_HISTOGRAMS = {
"js-main-runtime-gc-heap": "MEMORY_JS_GC_HEAP",
"redundant/js-main-runtime-compartments/system": "MEMORY_JS_COMPARTMENTS_SYSTEM",
"redundant/js-main-runtime-compartments/user": "MEMORY_JS_COMPARTMENTS_USER",
"js-main-runtime-temporary-peak": "MEMORY_JS_MAIN_RUNTIME_TEMPORARY_PEAK",
"redundant/resident-fast": "MEMORY_RESIDENT",
"vsize": "MEMORY_VSIZE",
"storage-sqlite": "MEMORY_STORAGE_SQLITE",
"images-content-used-uncompressed":
"MEMORY_IMAGES_CONTENT_USED_UNCOMPRESSED",
"heap-allocated": "MEMORY_HEAP_ALLOCATED",
"heap-overhead": "MEMORY_HEAP_COMMITTED_UNUSED",
"heap-overhead-ratio": "MEMORY_HEAP_COMMITTED_UNUSED_RATIO",
"page-faults-hard": "PAGE_FAULTS_HARD",
"low-memory-events/virtual": "LOW_MEMORY_EVENTS_VIRTUAL",
"low-memory-events/physical": "LOW_MEMORY_EVENTS_PHYSICAL",
"ghost-windows": "GHOST_WINDOWS"
};
// Seconds of idle time before pinging.
// On idle-daily a gather-telemetry notification is fired, during it probes can
// start asynchronous tasks to gather data. On the next idle the data is sent.
@ -414,57 +447,39 @@ TelemetryPing.prototype = {
let histogram = Telemetry.getHistogramById("TELEMETRY_MEMORY_REPORTER_MS");
let startTime = new Date();
let e = mgr.enumerateReporters();
while (e.hasMoreElements()) {
let mr = e.getNext().QueryInterface(Ci.nsIMemoryReporter);
let id = MEM_HISTOGRAMS[mr.name];
if (!id) {
continue;
}
// Get memory measurements from distinguished amount attributes. We used
// to measure "explicit" too, but it could cause hangs, and the data was
// always really noisy anyway. See bug 859657.
//
// test_TelemetryPing.js relies on some of these histograms being
// here. If you remove any of the following histograms from here, you'll
// have to modify test_TelemetryPing.js:
//
// * MEMORY_JS_GC_HEAP, and
// * MEMORY_JS_COMPARTMENTS_SYSTEM.
//
// The distinguished amount attribute names don't match the telemetry id
// names in some cases due to a combination of (a) historical reasons, and
// (b) the fact that we can't change telemetry id names without breaking
// data continuity.
//
let boundHandleMemoryReport = this.handleMemoryReport.bind(this);
function h(id, units, amountName) {
// collectReports might throw an exception. If so, just ignore that
// memory reporter; we're not getting useful data out of it.
try {
// If mgr[amountName] throws an exception, just move on -- some amounts
// aren't available on all platforms. But if the attribute simply
// isn't present, that indicates the distinguished amounts have changed
// and this file hasn't been updated appropriately.
let amount = mgr[amountName];
NS_ASSERT(amount !== undefined,
"telemetry accessed an unknown distinguished amount");
boundHandleMemoryReport(id, units, amount);
} catch (e) {
};
// Bind handleMemoryReport() so it can be called inside the closure
// used as the callback.
let boundHandleMemoryReport = this.handleMemoryReport.bind(this);
// Reporters used for telemetry should be uni-reporters! we assert if
// they make more than one report.
let hasReported = false;
function h(process, path, kind, units, amount, desc) {
if (!hasReported) {
boundHandleMemoryReport(id, units, amount);
hasReported = true;
} else {
NS_ASSERT(false,
"reporter " + mr.name + " has made more than one report");
}
}
mr.collectReports(h, null);
}
catch (e) {
}
}
let b = (id, n) => h(id, Ci.nsIMemoryReporter.UNITS_BYTES, n);
let c = (id, n) => h(id, Ci.nsIMemoryReporter.UNITS_COUNT, n);
let cc= (id, n) => h(id, Ci.nsIMemoryReporter.UNITS_COUNT_CUMULATIVE, n);
let p = (id, n) => h(id, Ci.nsIMemoryReporter.UNITS_PERCENTAGE, n);
b("MEMORY_VSIZE", "vsize");
b("MEMORY_RESIDENT", "residentFast");
b("MEMORY_HEAP_ALLOCATED", "heapAllocated");
p("MEMORY_HEAP_COMMITTED_UNUSED_RATIO", "heapOverheadRatio");
b("MEMORY_JS_GC_HEAP", "JSMainRuntimeGCHeap");
b("MEMORY_JS_MAIN_RUNTIME_TEMPORARY_PEAK", "JSMainRuntimeTemporaryPeak");
c("MEMORY_JS_COMPARTMENTS_SYSTEM", "JSMainRuntimeCompartmentsSystem");
c("MEMORY_JS_COMPARTMENTS_USER", "JSMainRuntimeCompartmentsUser");
b("MEMORY_IMAGES_CONTENT_USED_UNCOMPRESSED", "imagesContentUsedUncompressed");
b("MEMORY_STORAGE_SQLITE", "storageSQLite");
cc("MEMORY_EVENTS_VIRTUAL", "lowMemoryEventsVirtual");
cc("MEMORY_EVENTS_PHYSICAL", "lowMemoryEventsPhysical");
c("GHOST_WINDOWS", "ghostWindows");
cc("PAGE_FAULTS_HARD", "pageFaultsHard");
histogram.add(new Date() - startTime);
},

18
xpcom/base/AvailableMemoryTracker.cpp
View File

@ -325,12 +325,6 @@ CreateDIBSectionHook(HDC aDC,
return result;
}
static int64_t
LowMemoryEventsVirtualDistinguishedAmount()
{
return sNumLowVirtualMemEvents;
}
class LowMemoryEventsVirtualReporter MOZ_FINAL : public MemoryUniReporter
{
public:
@ -351,7 +345,7 @@ private:
// force-disable virtual-memory tracking there.
MOZ_ASSERT(sizeof(void*) == 4);
return LowMemoryEventsVirtualDistinguishedAmount();
return sNumLowVirtualMemEvents;
}
};
@ -372,12 +366,6 @@ private:
int64_t Amount() MOZ_OVERRIDE { return sNumLowCommitSpaceEvents; }
};
static int64_t
LowMemoryEventsPhysicalDistinguishedAmount()
{
return sNumLowPhysicalMemEvents;
}
class LowMemoryEventsPhysicalReporter MOZ_FINAL : public MemoryUniReporter
{
public:
@ -392,7 +380,7 @@ public:
{}
private:
int64_t Amount() MOZ_OVERRIDE { return LowMemoryEventsPhysicalDistinguishedAmount(); }
int64_t Amount() MOZ_OVERRIDE { return sNumLowPhysicalMemEvents; }
};
#endif // defined(XP_WIN)
@ -515,8 +503,6 @@ void Activate()
if (sizeof(void*) == 4) {
NS_RegisterMemoryReporter(new LowMemoryEventsVirtualReporter());
}
RegisterLowMemoryEventsVirtualDistinguishedAmount(LowMemoryEventsVirtualDistinguishedAmount);
RegisterLowMemoryEventsPhysicalDistinguishedAmount(LowMemoryEventsPhysicalDistinguishedAmount);
sHooksActive = true;
#endif

148
xpcom/base/nsIMemoryReporter.idl
View File

@ -143,6 +143,11 @@ interface nsIMemoryReporterCallback : nsISupports
* description that is a sentence (i.e. starts with a capital letter and
* ends with a period, or similar).
*
* - The "redundant" tree is optional, and can be used for reports that are
* redundant w.r.t. other reports. These are useful for telemetry, and are
* not shown in about:memory. Reports in this tree are entirely
* unconstrained.
*
* - All other reports are unconstrained except that they must have a
* description that is a sentence.
*/
@ -184,21 +189,21 @@ interface nsIMemoryReporterManager : nsISupports
/*
* Return an enumerator of nsIMemoryReporters that are currently registered.
*/
nsISimpleEnumerator enumerateReporters();
nsISimpleEnumerator enumerateReporters ();
/*
* Register the given nsIMemoryReporter. After a reporter is registered,
* it will be available via enumerateReporters(). The Manager service
* will hold a strong reference to the given reporter.
*/
void registerReporter(in nsIMemoryReporter reporter);
void registerReporter (in nsIMemoryReporter reporter);
/*
* Unregister the given memory reporter.
*/
void unregisterReporter(in nsIMemoryReporter reporter);
void unregisterReporter (in nsIMemoryReporter reporter);
/*
/**
* These functions should only be used for testing purposes.
*/
void blockRegistration();
@ -208,94 +213,24 @@ interface nsIMemoryReporterManager : nsISupports
/*
* Initialize.
*/
void init();
void init ();
/*
* The memory reporter manager, for the most part, treats reporters
* registered with it as a black box. However, there are some
* "distinguished" amounts (as could be reported by a memory reporter) that
* the manager provides as attributes, because they are sufficiently
* interesting that we want external code (e.g. telemetry) to be able to rely
* on them.
*
* Note that these are not reporters and so enumerateReporters() does not
* look at them. However, they can be embedded in a reporter.
*
* Access to these attributes can fail. In particular, some of them are not
* available on all platforms.
*
* If you add a new distinguished amount, please update
* toolkit/components/aboutmemory/tests/test_memoryReporters.xul.
*
* |explicit| (UNITS_BYTES) The total size of explicit memory allocations,
* both at the OS-level (eg. via mmap, VirtualAlloc) and at the heap level
* (eg. via malloc, calloc, operator new). It covers all heap allocations,
* but will miss any OS-level ones not covered by memory reporters.
*
* |vsize| (UNITS_BYTES) The virtual size, i.e. the amount of address space
* taken up.
*
* |resident| (UNITS_BYTES) The resident size (a.k.a. RSS or physical memory
* used).
*
* |residentFast| (UNITS_BYTES) This is like |resident|, but on Mac OS
* |resident| can purge pages, which is slow. It also affects the result of
* |residentFast|, and so |resident| and |residentFast| should not be used
* together.
*
* |heapAllocated| (UNITS_BYTES) Memory mapped by the heap allocator.
*
* |heapOverheadRatio| (UNITS_PERCENTAGE) In the heap allocator, this is the
* ratio of committed, unused bytes to allocated bytes. Like all
* UNITS_PERCENTAGE measurements, its amount is multiplied by 100x so it can
* be represented by an int64_t.
*
* |JSMainRuntimeGCHeap| (UNITS_BYTES) Size of the main JS runtime's GC
* heap.
*
* |JSMainRuntimeTemporaryPeak| (UNITS_BYTES) Peak size of the transient
* storage in the main JSRuntime.
*
* |JSMainRuntimeCompartments{System,User}| (UNITS_COUNT) The number of
* {system,user} compartments in the main JS runtime.
*
* |imagesContentUsedUncompressed| (UNITS_BYTES) Memory used for decoded
* images in content.
*
* |storageSQLite| (UNITS_BYTES) Memory used by SQLite.
*
* |lowMemoryEvents{Virtual,Physical}| (UNITS_COUNT_CUMULATIVE) The number
* of low-{virtual,physical}-memory events that have occurred since the
* process started.
*
* |ghostWindows| (UNITS_COUNT) The number of ghost windows.
*
* |pageFaultsHard| (UNITS_COUNT_CUMULATIVE) The number of hard (a.k.a.
* major) page faults that have occurred since the process started.
* Get the resident size (aka. RSS, physical memory used). This reporter
* is special-cased because it's interesting and is available on most
* platforms. Accesses can fail.
*/
readonly attribute int64_t resident;
/*
* Get the total size of explicit memory allocations, both at the OS-level
* (eg. via mmap, VirtualAlloc) and at the heap level (eg. via malloc,
* calloc, operator new). (Nb: it covers all heap allocations, but will
* miss any OS-level ones not covered by memory reporters.) This reporter
* is special-cased because it's interesting, and is difficult to compute
* from JavaScript code. Accesses can fail.
*/
readonly attribute int64_t explicit;
readonly attribute int64_t vsize;
readonly attribute int64_t resident;
readonly attribute int64_t residentFast;
readonly attribute int64_t heapAllocated;
readonly attribute int64_t heapOverheadRatio;
readonly attribute int64_t JSMainRuntimeGCHeap;
readonly attribute int64_t JSMainRuntimeTemporaryPeak;
readonly attribute int64_t JSMainRuntimeCompartmentsSystem;
readonly attribute int64_t JSMainRuntimeCompartmentsUser;
readonly attribute int64_t imagesContentUsedUncompressed;
readonly attribute int64_t storageSQLite;
readonly attribute int64_t lowMemoryEventsVirtual;
readonly attribute int64_t lowMemoryEventsPhysical;
readonly attribute int64_t ghostWindows;
readonly attribute int64_t pageFaultsHard;
/*
* This attribute indicates if moz_malloc_usable_size() works.
@ -321,42 +256,6 @@ interface nsIMemoryReporterManager : nsISupports
XPCOM_API(nsresult) NS_RegisterMemoryReporter(nsIMemoryReporter* aReporter);
XPCOM_API(nsresult) NS_UnregisterMemoryReporter(nsIMemoryReporter* aReporter);
namespace mozilla {
// The memory reporter manager provides access to several distinguished
// amounts via attributes. Some of these amounts are provided by Gecko
// components that cannot be accessed directly from XPCOM code. So we provide
// the following functions for those components to be registered with the
// manager.
typedef int64_t (*InfallibleAmountFn)();
typedef nsresult (*FallibleAmountFn)(int64_t* aAmount);
#define DECL_REGISTER_DISTINGUISHED_AMOUNT(kind, name) \
nsresult Register##name##DistinguishedAmount(kind##AmountFn aAmountFn);
#define DECL_UNREGISTER_DISTINGUISHED_AMOUNT(name) \
nsresult Unregister##name##DistinguishedAmount();
DECL_REGISTER_DISTINGUISHED_AMOUNT(Infallible, JSMainRuntimeGCHeap)
DECL_REGISTER_DISTINGUISHED_AMOUNT(Infallible, JSMainRuntimeTemporaryPeak)
DECL_REGISTER_DISTINGUISHED_AMOUNT(Infallible, JSMainRuntimeCompartmentsSystem)
DECL_REGISTER_DISTINGUISHED_AMOUNT(Infallible, JSMainRuntimeCompartmentsUser)
DECL_REGISTER_DISTINGUISHED_AMOUNT(Infallible, ImagesContentUsedUncompressed)
DECL_REGISTER_DISTINGUISHED_AMOUNT(Infallible, StorageSQLite)
DECL_UNREGISTER_DISTINGUISHED_AMOUNT(StorageSQLite)
DECL_REGISTER_DISTINGUISHED_AMOUNT(Infallible, LowMemoryEventsVirtual)
DECL_REGISTER_DISTINGUISHED_AMOUNT(Infallible, LowMemoryEventsPhysical)
DECL_REGISTER_DISTINGUISHED_AMOUNT(Infallible, GhostWindows)
#undef DECL_REGISTER_DISTINGUISHED_AMOUNT
#undef DECL_UNREGISTER_DISTINGUISHED_AMOUNT
}
#if defined(MOZ_DMD)
namespace mozilla {
namespace dmd {
@ -494,4 +393,5 @@ protected:
} // namespace mozilla
%}

311
xpcom/base/nsMemoryReporterManager.cpp
View File

@ -16,10 +16,9 @@
#if defined(XP_LINUX)
#include "nsMemoryInfoDumper.h"
#endif
#include "mozilla/Attributes.h"
#include "mozilla/PodOperations.h"
#include "mozilla/Services.h"
#include "mozilla/Telemetry.h"
#include "mozilla/Attributes.h"
#include "mozilla/Services.h"
#ifndef XP_WIN
#include <unistd.h>
@ -427,6 +426,26 @@ public:
NS_IMETHOD GetAmount(int64_t* aAmount) { return GetResident(aAmount); }
};
// This is a "redundant/"-prefixed reporter, which means it's ignored by
// about:memory. This is good because the "resident" reporter can purge pages
// on MacOS, which affects the "resident-fast" results, and we don't want the
// measurements shown in about:memory to be affected by the (arbitrary) order
// of memory reporter execution. This reporter is used by telemetry.
class ResidentFastReporter MOZ_FINAL : public MemoryUniReporter
{
public:
ResidentFastReporter()
: MemoryUniReporter("redundant/resident-fast", KIND_OTHER, UNITS_BYTES,
"This is the same measurement as 'resident', but it tries to be as fast as "
"possible at the expense of accuracy. On most platforms this is identical to "
"the 'resident' measurement, but on Mac it may over-count. You should use "
"'resident-fast' where you care about latency of collection (e.g. in "
"telemetry). Otherwise you should use 'resident'.")
{}
NS_IMETHOD GetAmount(int64_t* aAmount) { return GetResidentFast(aAmount); }
};
#endif // HAVE_VSIZE_AND_RESIDENT_REPORTERS
#ifdef XP_UNIX
@ -464,18 +483,6 @@ public:
}
};
static nsresult
PageFaultsHardDistinguishedAmount(int64_t* aAmount)
{
struct rusage usage;
int err = getrusage(RUSAGE_SELF, &usage);
if (err != 0) {
return NS_ERROR_FAILURE;
}
*aAmount = usage.ru_majflt;
return NS_OK;
}
class PageFaultsHardReporter MOZ_FINAL : public MemoryUniReporter
{
public:
@ -495,7 +502,13 @@ public:
NS_IMETHOD GetAmount(int64_t* aAmount)
{
return PageFaultsHardDistinguishedAmount(aAmount);
struct rusage usage;
int err = getrusage(RUSAGE_SELF, &usage);
if (err != 0) {
return NS_ERROR_FAILURE;
}
*aAmount = usage.ru_majflt;
return NS_OK;
}
};
#endif // HAVE_PAGE_FAULT_REPORTERS
@ -508,25 +521,6 @@ public:
#ifdef HAVE_JEMALLOC_STATS
static int64_t
HeapAllocated()
{
jemalloc_stats_t stats;
jemalloc_stats(&stats);
return (int64_t) stats.allocated;
}
// This has UNITS_PERCENTAGE, so it is multiplied by 100x.
static int64_t
HeapOverheadRatio()
{
jemalloc_stats_t stats;
jemalloc_stats(&stats);
return (int64_t) 10000 *
(stats.waste + stats.bookkeeping + stats.page_cache) /
((double)stats.allocated);
}
class HeapAllocatedReporter MOZ_FINAL : public MemoryUniReporter
{
public:
@ -538,7 +532,12 @@ public:
"exact amount requested is not recorded.)")
{}
private:
int64_t Amount() MOZ_OVERRIDE { return HeapAllocated(); }
int64_t Amount() MOZ_OVERRIDE
{
jemalloc_stats_t stats;
jemalloc_stats(&stats);
return (int64_t) stats.allocated;
}
};
class HeapOverheadWasteReporter MOZ_FINAL : public MemoryUniReporter
@ -557,7 +556,7 @@ public:
"fragmented, or that allocator is performing poorly for some other reason.")
{}
private:
int64_t Amount() MOZ_OVERRIDE
int64_t Amount()
{
jemalloc_stats_t stats;
jemalloc_stats(&stats);
@ -574,7 +573,7 @@ public:
"Committed bytes which the heap allocator uses for internal data structures.")
{}
private:
int64_t Amount() MOZ_OVERRIDE
int64_t Amount()
{
jemalloc_stats_t stats;
jemalloc_stats(&stats);
@ -594,7 +593,7 @@ public:
"is typically not larger than a few megabytes.")
{}
private:
int64_t Amount() MOZ_OVERRIDE
int64_t Amount()
{
jemalloc_stats_t stats;
jemalloc_stats(&stats);
@ -614,7 +613,7 @@ public:
"exactly.")
{}
private:
int64_t Amount() MOZ_OVERRIDE
int64_t Amount()
{
jemalloc_stats_t stats;
jemalloc_stats(&stats);
@ -634,7 +633,14 @@ public:
"the heap allocator relative to amount of memory allocated.")
{}
private:
int64_t Amount() MOZ_OVERRIDE { return HeapOverheadRatio(); }
int64_t Amount()
{
jemalloc_stats_t stats;
jemalloc_stats(&stats);
return (int64_t) 10000 *
(stats.waste + stats.bookkeeping + stats.page_cache) /
((double)stats.allocated);
}
};
#endif // HAVE_JEMALLOC_STATS
@ -651,10 +657,7 @@ public:
"Memory used by the dynamic and static atoms tables.")
{}
private:
int64_t Amount() MOZ_OVERRIDE
{
return NS_SizeOfAtomTablesIncludingThis(MallocSizeOf);
}
int64_t Amount() { return NS_SizeOfAtomTablesIncludingThis(MallocSizeOf); }
};
#ifdef MOZ_DMD
@ -749,6 +752,7 @@ nsMemoryReporterManager::Init()
#ifdef HAVE_VSIZE_AND_RESIDENT_REPORTERS
RegisterReporter(new VsizeReporter);
RegisterReporter(new ResidentReporter);
RegisterReporter(new ResidentFastReporter);
#endif
#ifdef HAVE_RESIDENT_UNIQUE_REPORTER
@ -844,7 +848,6 @@ nsMemoryReporterManager::nsMemoryReporterManager()
: mMutex("nsMemoryReporterManager::mMutex"),
mIsRegistrationBlocked(false)
{
PodZero(&mAmountFns);
}
nsMemoryReporterManager::~nsMemoryReporterManager()
@ -961,6 +964,17 @@ nsMemoryReporterManager::UnblockRegistration()
return NS_OK;
}
NS_IMETHODIMP
nsMemoryReporterManager::GetResident(int64_t* aResident)
{
#ifdef HAVE_VSIZE_AND_RESIDENT_REPORTERS
return ::GetResident(aResident);
#else
*aResident = 0;
return NS_ERROR_NOT_AVAILABLE;
#endif
}
// This is just a wrapper for int64_t that implements nsISupports, so it can be
// passed to nsIMemoryReporter::CollectReports.
class Int64Wrapper MOZ_FINAL : public nsISupports {
@ -981,12 +995,6 @@ public:
const nsACString& aDescription,
nsISupports* aWrappedExplicit)
{
// Using the "heap-allocated" reporter here instead of
// nsMemoryReporterManager.heapAllocated goes against the usual
// pattern. But it's for a good reason: in tests, we can easily
// create artificial (i.e. deterministic) reporters -- which allows us
// to precisely test nsMemoryReporterManager.explicit -- but we can't
// do that for distinguished amounts.
if (aPath.Equals("heap-allocated") ||
(aKind == nsIMemoryReporter::KIND_NONHEAP &&
PromiseFlatCString(aPath).Find("explicit") == 0))
@ -1001,10 +1009,10 @@ public:
NS_IMPL_ISUPPORTS1(ExplicitCallback, nsIMemoryReporterCallback)
NS_IMETHODIMP
nsMemoryReporterManager::GetExplicit(int64_t* aAmount)
nsMemoryReporterManager::GetExplicit(int64_t* aExplicit)
{
NS_ENSURE_ARG_POINTER(aAmount);
*aAmount = 0;
NS_ENSURE_ARG_POINTER(aExplicit);
*aExplicit = 0;
#ifndef HAVE_JEMALLOC_STATS
return NS_ERROR_NOT_AVAILABLE;
#else
@ -1027,149 +1035,12 @@ nsMemoryReporterManager::GetExplicit(int64_t* aAmount)
r->CollectReports(cb, wrappedExplicitSize);
}
*aAmount = wrappedExplicitSize->mValue;
*aExplicit = wrappedExplicitSize->mValue;
return NS_OK;
#endif // HAVE_JEMALLOC_STATS
}
NS_IMETHODIMP
nsMemoryReporterManager::GetVsize(int64_t* aVsize)
{
#ifdef HAVE_VSIZE_AND_RESIDENT_REPORTERS
return ::GetVsize(aVsize);
#else
*aResident = 0;
return NS_ERROR_NOT_AVAILABLE;
#endif
}
NS_IMETHODIMP
nsMemoryReporterManager::GetResident(int64_t* aAmount)
{
#ifdef HAVE_VSIZE_AND_RESIDENT_REPORTERS
return ::GetResident(aAmount);
#else
*aAmount = 0;
return NS_ERROR_NOT_AVAILABLE;
#endif
}
NS_IMETHODIMP
nsMemoryReporterManager::GetResidentFast(int64_t* aAmount)
{
#ifdef HAVE_VSIZE_AND_RESIDENT_REPORTERS
return ::GetResidentFast(aAmount);
#else
*aAmount = 0;
return NS_ERROR_NOT_AVAILABLE;
#endif
}
NS_IMETHODIMP
nsMemoryReporterManager::GetHeapAllocated(int64_t* aAmount)
{
#ifdef HAVE_JEMALLOC_STATS
*aAmount = HeapAllocated();
return NS_OK;
#else
*aAmount = 0;
return NS_ERROR_NOT_AVAILABLE;
#endif
}
// This has UNITS_PERCENTAGE, so it is multiplied by 100x.
NS_IMETHODIMP
nsMemoryReporterManager::GetHeapOverheadRatio(int64_t* aAmount)
{
#ifdef HAVE_JEMALLOC_STATS
*aAmount = HeapOverheadRatio();
return NS_OK;
#else
*aAmount = 0;
return NS_ERROR_NOT_AVAILABLE;
#endif
}
static nsresult
GetInfallibleAmount(InfallibleAmountFn aAmountFn, int64_t* aAmount)
{
if (aAmountFn) {
*aAmount = aAmountFn();
return NS_OK;
}
*aAmount = 0;
return NS_ERROR_NOT_AVAILABLE;
}
NS_IMETHODIMP
nsMemoryReporterManager::GetJSMainRuntimeGCHeap(int64_t* aAmount)
{
return GetInfallibleAmount(mAmountFns.mJSMainRuntimeGCHeap, aAmount);
}
NS_IMETHODIMP
nsMemoryReporterManager::GetJSMainRuntimeTemporaryPeak(int64_t* aAmount)
{
return GetInfallibleAmount(mAmountFns.mJSMainRuntimeTemporaryPeak, aAmount);
}
NS_IMETHODIMP
nsMemoryReporterManager::GetJSMainRuntimeCompartmentsSystem(int64_t* aAmount)
{
return GetInfallibleAmount(mAmountFns.mJSMainRuntimeCompartmentsSystem,
aAmount);
}
NS_IMETHODIMP
nsMemoryReporterManager::GetJSMainRuntimeCompartmentsUser(int64_t* aAmount)
{
return GetInfallibleAmount(mAmountFns.mJSMainRuntimeCompartmentsUser,
aAmount);
}
NS_IMETHODIMP
nsMemoryReporterManager::GetImagesContentUsedUncompressed(int64_t* aAmount)
{
return GetInfallibleAmount(mAmountFns.mImagesContentUsedUncompressed,
aAmount);
}
NS_IMETHODIMP
nsMemoryReporterManager::GetStorageSQLite(int64_t* aAmount)
{
return GetInfallibleAmount(mAmountFns.mStorageSQLite, aAmount);
}
NS_IMETHODIMP
nsMemoryReporterManager::GetLowMemoryEventsVirtual(int64_t* aAmount)
{
return GetInfallibleAmount(mAmountFns.mLowMemoryEventsVirtual, aAmount);
}
NS_IMETHODIMP
nsMemoryReporterManager::GetLowMemoryEventsPhysical(int64_t* aAmount)
{
return GetInfallibleAmount(mAmountFns.mLowMemoryEventsPhysical, aAmount);
}
NS_IMETHODIMP
nsMemoryReporterManager::GetGhostWindows(int64_t* aAmount)
{
return GetInfallibleAmount(mAmountFns.mGhostWindows, aAmount);
}
NS_IMETHODIMP
nsMemoryReporterManager::GetPageFaultsHard(int64_t* aAmount)
{
#ifdef HAVE_PAGE_FAULT_REPORTERS
return PageFaultsHardDistinguishedAmount(aAmount);
#else
*aAmount = 0;
return NS_ERROR_NOT_AVAILABLE;
#endif
}
NS_IMETHODIMP
nsMemoryReporterManager::GetHasMozMallocUsableSize(bool* aHas)
{
@ -1292,60 +1163,6 @@ NS_UnregisterMemoryReporter(nsIMemoryReporter* aReporter)
return mgr->UnregisterReporter(aReporter);
}
namespace mozilla {
// Macro for generating functions that register distinguished amount functions
// with the memory reporter manager.
#define DEFINE_REGISTER_DISTINGUISHED_AMOUNT(kind, name) \
nsresult \
Register##name##DistinguishedAmount(kind##AmountFn aAmountFn) \
{ \
nsCOMPtr<nsIMemoryReporterManager> imgr = \
do_GetService("@mozilla.org/memory-reporter-manager;1"); \
nsRefPtr<nsMemoryReporterManager> mgr = \
static_cast<nsMemoryReporterManager*>(imgr.get()); \
if (!mgr) { \
return NS_ERROR_FAILURE; \
} \
mgr->mAmountFns.m##name = aAmountFn; \
return NS_OK; \
}
#define DEFINE_UNREGISTER_DISTINGUISHED_AMOUNT(name) \
nsresult \
Unregister##name##DistinguishedAmount() \
{ \
nsCOMPtr<nsIMemoryReporterManager> imgr = \
do_GetService("@mozilla.org/memory-reporter-manager;1"); \
nsRefPtr<nsMemoryReporterManager> mgr = \
static_cast<nsMemoryReporterManager*>(imgr.get()); \
if (!mgr) { \
return NS_ERROR_FAILURE; \
} \
mgr->mAmountFns.m##name = nullptr; \
return NS_OK; \
}
DEFINE_REGISTER_DISTINGUISHED_AMOUNT(Infallible, JSMainRuntimeGCHeap)
DEFINE_REGISTER_DISTINGUISHED_AMOUNT(Infallible, JSMainRuntimeTemporaryPeak)
DEFINE_REGISTER_DISTINGUISHED_AMOUNT(Infallible, JSMainRuntimeCompartmentsSystem)
DEFINE_REGISTER_DISTINGUISHED_AMOUNT(Infallible, JSMainRuntimeCompartmentsUser)
DEFINE_REGISTER_DISTINGUISHED_AMOUNT(Infallible, ImagesContentUsedUncompressed)
DEFINE_REGISTER_DISTINGUISHED_AMOUNT(Infallible, StorageSQLite)
DEFINE_UNREGISTER_DISTINGUISHED_AMOUNT(StorageSQLite)
DEFINE_REGISTER_DISTINGUISHED_AMOUNT(Infallible, LowMemoryEventsVirtual)
DEFINE_REGISTER_DISTINGUISHED_AMOUNT(Infallible, LowMemoryEventsPhysical)
DEFINE_REGISTER_DISTINGUISHED_AMOUNT(Infallible, GhostWindows)
#undef DEFINE_REGISTER_DISTINGUISHED_AMOUNT
#undef DEFINE_UNREGISTER_DISTINGUISHED_AMOUNT
}
#if defined(MOZ_DMD)
namespace mozilla {

21
xpcom/base/nsMemoryReporterManager.h
View File

@ -20,27 +20,8 @@ public:
nsMemoryReporterManager();
virtual ~nsMemoryReporterManager();
// 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 mAmountFns;
private:
nsresult RegisterReporterHelper(nsIMemoryReporter *aReporter, bool aForce);
nsresult RegisterReporterHelper(nsIMemoryReporter *reporter, bool aForce);
nsTHashtable<nsISupportsHashKey> mReporters;
Mutex mMutex;