wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Bug 671280 - Rename KIND_MAPPED to KIND_NONHEAP in nsIMemoryReporter. r=njn

Browse Source
This commit is contained in:
Justin Lebar 2011-07-19 10:33:49 -04:00
parent f341dfca7a
commit 470956d8ab
5 changed files with 91 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
js/src/xpconnect/src/xpcjsruntime.cpp
View File

@ -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"),

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

@ -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 "(???) ";
}
}

86
toolkit/components/aboutmemory/tests/chrome/test_aboutmemory.xul
View File

@ -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<script>window.alert(1)</script>",
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]);

23
xpcom/base/nsIMemoryReporter.idl
View File

@ -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.

36
xpcom/base/nsMemoryReporterManager.cpp
View File

@ -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<MemoryReportsWrapper *>(aWrappedMRs);
MemoryReport mr(aPath, aAmount);
@ -603,10 +603,10 @@ isParent(const nsACString &path1, const nsACString &path2)
NS_IMETHODIMP
nsMemoryReporterManager::GetExplicit(PRInt64 *aExplicit)
{
InfallibleTArray<MemoryReport> mapped;
InfallibleTArray<MemoryReport> 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<nsISimpleEnumerator> 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<nsISimpleEnumerator> e2;
EnumerateMultiReporters(getter_AddRefs(e2));
nsRefPtr<MemoryReportsWrapper> wrappedMRs =
new MemoryReportsWrapper(&mapped);
new MemoryReportsWrapper(&nonheap);
nsRefPtr<MemoryReportCallback> 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;