From b8fa6f6a6a8483dd2ac34b471dfc3b009b6045ba Mon Sep 17 00:00:00 2001 From: Justin Lebar Date: Tue, 19 Jul 2011 10:33:49 -0400 Subject: [PATCH] Bug 671280 - Rename KIND_MAPPED to KIND_NONHEAP in nsIMemoryReporter. r=njn --- js/src/xpconnect/src/xpcjsruntime.cpp | 10 +-- .../aboutmemory/content/aboutMemory.js | 18 ++-- .../tests/chrome/test_aboutmemory.xul | 86 +++++++++---------- xpcom/base/nsIMemoryReporter.idl | 23 +++-- xpcom/base/nsMemoryReporterManager.cpp | 36 ++++---- 5 files changed, 91 insertions(+), 82 deletions(-) diff --git a/js/src/xpconnect/src/xpcjsruntime.cpp b/js/src/xpconnect/src/xpcjsruntime.cpp index 6bf0acb344a..c0fc40f1a0c 100644 --- a/js/src/xpconnect/src/xpcjsruntime.cpp +++ b/js/src/xpconnect/src/xpcjsruntime.cpp @@ -1266,7 +1266,7 @@ static XPConnectGCChunkAllocator gXPCJSChunkAllocator; #ifdef MOZ_MEMORY #define JS_GC_HEAP_KIND nsIMemoryReporter::KIND_HEAP #else -#define JS_GC_HEAP_KIND nsIMemoryReporter::KIND_MAPPED +#define JS_GC_HEAP_KIND nsIMemoryReporter::KIND_NONHEAP #endif // We have per-compartment GC heap totals, so we can't put the total GC heap @@ -1291,11 +1291,11 @@ GetJSStack() NS_MEMORY_REPORTER_IMPLEMENT(XPConnectJSStack, "explicit/js/stack", - KIND_MAPPED, + KIND_NONHEAP, nsIMemoryReporter::UNITS_BYTES, GetJSStack, "Memory used for the JavaScript stack. This is the committed portion " - "of the stack; any uncommitted portion is not measured because it " + "of the stack; any uncommitted portion is not measured because it " "hardly costs anything.") class XPConnectJSCompartmentsMultiReporter : public nsIMemoryMultiReporter @@ -1622,7 +1622,7 @@ public: #ifdef JS_METHODJIT DO(mkPath(name, "mjit-code"), - nsIMemoryReporter::KIND_MAPPED, stats->mjitCode, + nsIMemoryReporter::KIND_NONHEAP, stats->mjitCode, "Memory used by the method JIT to hold generated code."); DO(mkPath(name, "mjit-data"), @@ -1632,7 +1632,7 @@ public: #endif #ifdef JS_TRACER DO(mkPath(name, "tjit-code"), - nsIMemoryReporter::KIND_MAPPED, stats->tjitCode, + nsIMemoryReporter::KIND_NONHEAP, stats->tjitCode, "Memory used by the trace JIT to hold generated code."); DO(mkPath(name, "tjit-data/allocators-main"), diff --git a/toolkit/components/aboutmemory/content/aboutMemory.js b/toolkit/components/aboutmemory/content/aboutMemory.js index 7a9ff6027c3..d21d8e50f68 100644 --- a/toolkit/components/aboutmemory/content/aboutMemory.js +++ b/toolkit/components/aboutmemory/content/aboutMemory.js @@ -48,11 +48,11 @@ var gVerbose = (location.href.split(/[\?,]/).indexOf("verbose") !== -1); var gAddedObserver = false; -const KIND_MAPPED = Ci.nsIMemoryReporter.KIND_MAPPED; -const KIND_HEAP = Ci.nsIMemoryReporter.KIND_HEAP; -const KIND_OTHER = Ci.nsIMemoryReporter.KIND_OTHER; -const UNITS_BYTES = Ci.nsIMemoryReporter.UNITS_BYTES; -const UNITS_COUNT = Ci.nsIMemoryReporter.UNITS_COUNT; +const KIND_NONHEAP = Ci.nsIMemoryReporter.KIND_NONHEAP; +const KIND_HEAP = Ci.nsIMemoryReporter.KIND_HEAP; +const KIND_OTHER = Ci.nsIMemoryReporter.KIND_OTHER; +const UNITS_BYTES = Ci.nsIMemoryReporter.UNITS_BYTES; +const UNITS_COUNT = Ci.nsIMemoryReporter.UNITS_COUNT; const kUnknown = -1; // used for _amount if a memory reporter failed @@ -649,10 +649,10 @@ function genMrValueText(aValue) function kindToString(aKind) { switch (aKind) { - case KIND_MAPPED: return "(Mapped) "; - case KIND_HEAP: return "(Heap) "; - case KIND_OTHER: return ""; - default: return "(???) "; + case KIND_NONHEAP: return "(Non-heap) "; + case KIND_HEAP: return "(Heap) "; + case KIND_OTHER: return ""; + default: return "(???) "; } } diff --git a/toolkit/components/aboutmemory/tests/chrome/test_aboutmemory.xul b/toolkit/components/aboutmemory/tests/chrome/test_aboutmemory.xul index 5ef3daf1993..c55c3fdf6a6 100644 --- a/toolkit/components/aboutmemory/tests/chrome/test_aboutmemory.xul +++ b/toolkit/components/aboutmemory/tests/chrome/test_aboutmemory.xul @@ -47,9 +47,9 @@ const KB = 1024; const MB = KB * KB; const kUnknown = -1; - const MAPPED = Ci.nsIMemoryReporter.KIND_MAPPED; - const HEAP = Ci.nsIMemoryReporter.KIND_HEAP; - const OTHER = Ci.nsIMemoryReporter.KIND_OTHER; + const NONHEAP = Ci.nsIMemoryReporter.KIND_NONHEAP; + const HEAP = Ci.nsIMemoryReporter.KIND_HEAP; + const OTHER = Ci.nsIMemoryReporter.KIND_OTHER; const BYTES = Ci.nsIMemoryReporter.UNITS_BYTES; const COUNT = Ci.nsIMemoryReporter.UNITS_COUNT; @@ -70,38 +70,38 @@ } var fakeReporters = [ - f("", "heap-allocated", OTHER, 500 * MB), - f("", "heap-unallocated", OTHER, 100 * MB), - f("", "explicit/a", HEAP, 222 * MB), - f("", "explicit/b/a", HEAP, 85 * MB), - f("", "explicit/b/b", HEAP, 75 * MB), - f("", "explicit/b/c/a", HEAP, 70 * MB), - f("", "explicit/b/c/b", HEAP, 2 * MB), // omitted - f("", "explicit/c", MAPPED, 100 * MB), - f("", "explicit/c/d", MAPPED, 13 * MB), // subsumed by parent - f("", "explicit/g", HEAP, 1 * MB), // internal, dup: merge - f("", "explicit/g/a", HEAP, 6 * MB), - f("", "explicit/g/b", HEAP, 5 * MB), - f("", "other1", OTHER, 111 * MB), - f2("", "other4", OTHER, COUNT, 888), - f2("", "unknown-unit", OTHER, /*bogus unit*/999, 999) + f("", "heap-allocated", OTHER, 500 * MB), + f("", "heap-unallocated", OTHER, 100 * MB), + f("", "explicit/a", HEAP, 222 * MB), + f("", "explicit/b/a", HEAP, 85 * MB), + f("", "explicit/b/b", HEAP, 75 * MB), + f("", "explicit/b/c/a", HEAP, 70 * MB), + f("", "explicit/b/c/b", HEAP, 2 * MB), // omitted + f("", "explicit/c", NONHEAP, 100 * MB), + f("", "explicit/c/d", NONHEAP, 13 * MB), // subsumed by parent + f("", "explicit/g", HEAP, 1 * MB), // internal, dup: merge + f("", "explicit/g/a", HEAP, 6 * MB), + f("", "explicit/g/b", HEAP, 5 * MB), + f("", "other1", OTHER, 111 * MB), + f2("", "other4", OTHER, COUNT, 888), + f2("", "unknown-unit", OTHER, /*bogus unit*/999, 999) ]; var fakeMultiReporters = [ { collectReports: function(cbObj, closure) { function f(p, k, u, a) { cbObj.callback("", p, k, u, a, "(desc)", closure); } - f("explicit/c/d", MAPPED, BYTES, 10 * MB), // dup, subsumed by parent - f("explicit/cc", MAPPED, BYTES, 13 * MB); - f("explicit/cc", MAPPED, BYTES, 10 * MB); // dup - f("explicit/d", MAPPED, BYTES, 499 * KB); // omitted - f("explicit/e", MAPPED, BYTES, 100 * KB); // omitted - f("explicit/f/g/h/i", HEAP, BYTES, 20 * MB); + f("explicit/c/d", NONHEAP, BYTES, 10 * MB), // dup, subsumed by parent + f("explicit/cc", NONHEAP, BYTES, 13 * MB); + f("explicit/cc", NONHEAP, BYTES, 10 * MB); // dup + f("explicit/d", NONHEAP, BYTES, 499 * KB); // omitted + f("explicit/e", NONHEAP, BYTES, 100 * KB); // omitted + f("explicit/f/g/h/i", HEAP, BYTES, 20 * MB); } }, { collectReports: function(cbObj, closure) { function f(p, k, u, a) { cbObj.callback("", p, k, u, a, "(desc)", closure); } - f("explicit/g", HEAP, BYTES, 14 * MB); // internal - f("other2", OTHER, BYTES, 222 * MB); - f("other3", OTHER, COUNT, 777); + f("explicit/g", HEAP, BYTES, 14 * MB); // internal + f("other2", OTHER, BYTES, 222 * MB); + f("other3", OTHER, COUNT, 777); } } ]; @@ -112,7 +112,7 @@ mgr.registerMultiReporter(fakeMultiReporters[i]); } - // mgr.explicit sums "heap-allocated" and all the appropriate MAPPED ones: + // mgr.explicit sums "heap-allocated" and all the appropriate NONHEAP ones: // - "explicit/c", "explicit/cc" x 2, "explicit/d", "explicit/e" // - but *not* "explicit/c/d" x 2 // Check explicit now before we add the fake reporters for the fake 2nd @@ -124,28 +124,28 @@ dummy = mgr.resident; var fakeReporters2 = [ - f("2nd", "heap-allocated", OTHER, 1000 * MB), - f("2nd", "heap-unallocated", OTHER, 100 * MB), - f("2nd", "explicit/a/b/c", HEAP, 498 * MB), - f("2nd", "explicit/a/b/c", HEAP, 1 * MB), // dup: merge + f("2nd", "heap-allocated", OTHER, 1000 * MB), + f("2nd", "heap-unallocated",OTHER, 100 * MB), + f("2nd", "explicit/a/b/c", HEAP, 498 * MB), + f("2nd", "explicit/a/b/c", HEAP, 1 * MB), // dup: merge f("2nd", "explicit/flip\\the\\backslashes", - HEAP, 200 * MB), + HEAP, 200 * MB), f("2nd", "explicit/compartment(this-will-be-truncated-in-non-verbose-mode-abcdefghijklmnopqrstuvwxyz)", - HEAP, 200 * MB), + HEAP, 200 * MB), // The escaping of compartment names must prevent this script from running. f("2nd", "danger", - OTHER, 666 * MB), - f("2nd", "other1", OTHER, 111 * MB), + OTHER, 666 * MB), + f("2nd", "other1", OTHER, 111 * MB), // kUnknown should be handled gracefully for "heap-allocated", non-leaf // reporters, leaf-reporters, and "other" reporters. - f("3rd", "heap-allocated", OTHER, kUnknown), - f("3rd", "explicit/a", HEAP, kUnknown), - f("3rd", "explicit/a/b", HEAP, 333 * MB), - f("3rd", "explicit/a/c", HEAP, 444 * MB), - f("3rd", "explicit/a/d", HEAP, kUnknown), - f("3rd", "explicit/b", MAPPED,kUnknown), - f("3rd", "other1", OTHER, kUnknown) + f("3rd", "heap-allocated", OTHER, kUnknown), + f("3rd", "explicit/a", HEAP, kUnknown), + f("3rd", "explicit/a/b", HEAP, 333 * MB), + f("3rd", "explicit/a/c", HEAP, 444 * MB), + f("3rd", "explicit/a/d", HEAP, kUnknown), + f("3rd", "explicit/b", NONHEAP, kUnknown), + f("3rd", "other1", OTHER, kUnknown) ]; for (var i = 0; i < fakeReporters2.length; i++) { mgr.registerReporter(fakeReporters2[i]); diff --git a/xpcom/base/nsIMemoryReporter.idl b/xpcom/base/nsIMemoryReporter.idl index b2770c9e00d..02ee8c2e4d5 100644 --- a/xpcom/base/nsIMemoryReporter.idl +++ b/xpcom/base/nsIMemoryReporter.idl @@ -99,22 +99,31 @@ interface nsIMemoryReporter : nsISupports /* * There are three categories of memory reporters: * - * - MAPPED: memory allocated directly by the OS, e.g. by calling mmap, - * VirtualAlloc, or vm_allocate. Reporters in this category must have - * units UNITS_BYTES and must have a path starting with "explicit". - * * - HEAP: memory allocated by the heap allocator, e.g. by calling malloc, * calloc, realloc, memalign, operator new, or operator new[]. Reporters * in this category must have units UNITS_BYTES and must have a path * starting with "explicit". + + * - NONHEAP: memory which the program explicitly allocated, but does not + * live on the heap. Such memory is commonly allocated by calling one of + * the OS's memory-mapping functions (e.g. mmap, VirtualAlloc, or + * vm_allocate). Reporters in this category must have units UNITS_BYTES + * and must have a path starting with "explicit". * * - OTHER: reporters which don't fit into either of these categories. Such * reporters must have a path that does not start with "explicit" and may * have any units. */ - const PRInt32 KIND_MAPPED = 0; - const PRInt32 KIND_HEAP = 1; - const PRInt32 KIND_OTHER = 2; + const PRInt32 KIND_NONHEAP = 0; + const PRInt32 KIND_HEAP = 1; + const PRInt32 KIND_OTHER = 2; + + /* + * KIND_MAPPED is a deprecated synonym for KIND_NONHEAP. We keep it around + * to as not to break extensions which might use this interface, but we will + * remove it eventually. + */ + const PRInt32 KIND_MAPPED = 0; /* * The reporter kind. See KIND_* above. diff --git a/xpcom/base/nsMemoryReporterManager.cpp b/xpcom/base/nsMemoryReporterManager.cpp index c3caf12e510..f234c8520a9 100644 --- a/xpcom/base/nsMemoryReporterManager.cpp +++ b/xpcom/base/nsMemoryReporterManager.cpp @@ -574,7 +574,7 @@ public: const nsACString &aDescription, nsISupports *aWrappedMRs) { - if (aKind == nsIMemoryReporter::KIND_MAPPED && aAmount != PRInt64(-1)) { + if (aKind == nsIMemoryReporter::KIND_NONHEAP && aAmount != PRInt64(-1)) { MemoryReportsWrapper *wrappedMRs = static_cast(aWrappedMRs); MemoryReport mr(aPath, aAmount); @@ -603,10 +603,10 @@ isParent(const nsACString &path1, const nsACString &path2) NS_IMETHODIMP nsMemoryReporterManager::GetExplicit(PRInt64 *aExplicit) { - InfallibleTArray mapped; + InfallibleTArray nonheap; PRInt64 heapUsed = PRInt64(-1); - // Get "heap-allocated" and all the KIND_MAPPED measurements from vanilla + // Get "heap-allocated" and all the KIND_NONHEAP measurements from vanilla // reporters. nsCOMPtr e; EnumerateReporters(getter_AddRefs(e)); @@ -620,7 +620,7 @@ nsMemoryReporterManager::GetExplicit(PRInt64 *aExplicit) nsresult rv = r->GetKind(&kind); NS_ENSURE_SUCCESS(rv, rv); - if (kind == nsIMemoryReporter::KIND_MAPPED) { + if (kind == nsIMemoryReporter::KIND_NONHEAP) { nsCString path; rv = r->GetPath(path); NS_ENSURE_SUCCESS(rv, rv); @@ -629,11 +629,11 @@ nsMemoryReporterManager::GetExplicit(PRInt64 *aExplicit) rv = r->GetAmount(&amount); NS_ENSURE_SUCCESS(rv, rv); - // Just skip any MAPPED reporters that fail, because + // Just skip any NONHEAP reporters that fail, because // "heap-allocated" is the most important one. if (amount != PRInt64(-1)) { MemoryReport mr(path, amount); - mapped.AppendElement(mr); + nonheap.AppendElement(mr); } } else { nsCString path; @@ -653,11 +653,11 @@ nsMemoryReporterManager::GetExplicit(PRInt64 *aExplicit) } } - // Get KIND_MAPPED measurements from multi-reporters, too. + // Get KIND_NONHEAP measurements from multi-reporters, too. nsCOMPtr e2; EnumerateMultiReporters(getter_AddRefs(e2)); nsRefPtr wrappedMRs = - new MemoryReportsWrapper(&mapped); + new MemoryReportsWrapper(&nonheap); nsRefPtr cb = new MemoryReportCallback(); while (NS_SUCCEEDED(e2->HasMoreElements(&more)) && more) { @@ -668,24 +668,24 @@ nsMemoryReporterManager::GetExplicit(PRInt64 *aExplicit) // Ignore (by zeroing its amount) any reporter that is a child of another // reporter. Eg. if we have "explicit/a" and "explicit/a/b", zero the - // latter. This is quadratic in the number of MAPPED reporters, but there + // latter. This is quadratic in the number of NONHEAP reporters, but there // shouldn't be many. - for (PRUint32 i = 0; i < mapped.Length(); i++) { - const nsCString &iPath = mapped[i].path; - for (PRUint32 j = i + 1; j < mapped.Length(); j++) { - const nsCString &jPath = mapped[j].path; + for (PRUint32 i = 0; i < nonheap.Length(); i++) { + const nsCString &iPath = nonheap[i].path; + for (PRUint32 j = i + 1; j < nonheap.Length(); j++) { + const nsCString &jPath = nonheap[j].path; if (isParent(iPath, jPath)) { - mapped[j].amount = 0; + nonheap[j].amount = 0; } else if (isParent(jPath, iPath)) { - mapped[i].amount = 0; + nonheap[i].amount = 0; } } } - // Sum all the mapped reporters and heapUsed. + // Sum all the nonheap reporters and heapUsed. *aExplicit = heapUsed; - for (PRUint32 i = 0; i < mapped.Length(); i++) { - *aExplicit += mapped[i].amount; + for (PRUint32 i = 0; i < nonheap.Length(); i++) { + *aExplicit += nonheap[i].amount; } return NS_OK;