diff options
Diffstat (limited to 'toolkit/components/aboutmemory/content/aboutMemory.js')
| -rw-r--r-- | toolkit/components/aboutmemory/content/aboutMemory.js | 2042 |
1 files changed, 2042 insertions, 0 deletions
diff --git a/toolkit/components/aboutmemory/content/aboutMemory.js b/toolkit/components/aboutmemory/content/aboutMemory.js new file mode 100644 index 000000000..c62416dc5 --- /dev/null +++ b/toolkit/components/aboutmemory/content/aboutMemory.js @@ -0,0 +1,2042 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 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/. */ + +// You can direct about:memory to immediately load memory reports from a file +// by providing a file= query string. For example, +// +// about:memory?file=/home/username/reports.json.gz +// +// "file=" is not case-sensitive. We'll URI-unescape the contents of the +// "file=" argument, and obviously the filename is case-sensitive iff you're on +// a case-sensitive filesystem. If you specify more than one "file=" argument, +// only the first one is used. + +"use strict"; + +// --------------------------------------------------------------------------- + +var Cc = Components.classes; +var Ci = Components.interfaces; +var Cu = Components.utils; +var CC = Components.Constructor; + +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 UNITS_COUNT_CUMULATIVE = Ci.nsIMemoryReporter.UNITS_COUNT_CUMULATIVE; +const UNITS_PERCENTAGE = Ci.nsIMemoryReporter.UNITS_PERCENTAGE; + +Cu.import("resource://gre/modules/Services.jsm"); +Cu.import("resource://gre/modules/XPCOMUtils.jsm"); +Cu.import("resource://gre/modules/NetUtil.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "Downloads", + "resource://gre/modules/Downloads.jsm"); +XPCOMUtils.defineLazyModuleGetter(this, "FileUtils", + "resource://gre/modules/FileUtils.jsm"); + +XPCOMUtils.defineLazyGetter(this, "nsBinaryStream", + () => CC("@mozilla.org/binaryinputstream;1", + "nsIBinaryInputStream", + "setInputStream")); +XPCOMUtils.defineLazyGetter(this, "nsFile", + () => CC("@mozilla.org/file/local;1", + "nsIFile", "initWithPath")); +XPCOMUtils.defineLazyGetter(this, "nsGzipConverter", + () => CC("@mozilla.org/streamconv;1?from=gzip&to=uncompressed", + "nsIStreamConverter")); + +var gMgr = Cc["@mozilla.org/memory-reporter-manager;1"] + .getService(Ci.nsIMemoryReporterManager); + +const gPageName = 'about:memory'; +document.title = gPageName; + +const gUnnamedProcessStr = "Main Process"; + +var gIsDiff = false; + +// --------------------------------------------------------------------------- + +// Forward slashes in URLs in paths are represented with backslashes to avoid +// being mistaken for path separators. Paths/names where this hasn't been +// undone are prefixed with "unsafe"; the rest are prefixed with "safe". +function flipBackslashes(aUnsafeStr) +{ + // Save memory by only doing the replacement if it's necessary. + return (aUnsafeStr.indexOf('\\') === -1) + ? aUnsafeStr + : aUnsafeStr.replace(/\\/g, '/'); +} + +const gAssertionFailureMsgPrefix = "aboutMemory.js assertion failed: "; + +// This is used for things that should never fail, and indicate a defect in +// this file if they do. +function assert(aCond, aMsg) +{ + if (!aCond) { + reportAssertionFailure(aMsg) + throw new Error(gAssertionFailureMsgPrefix + aMsg); + } +} + +// This is used for malformed input from memory reporters. +function assertInput(aCond, aMsg) +{ + if (!aCond) { + throw new Error("Invalid memory report(s): " + aMsg); + } +} + +function handleException(ex) +{ + let str = "" + ex; + if (str.startsWith(gAssertionFailureMsgPrefix)) { + // Argh, assertion failure within this file! Give up. + throw ex; + } else { + // File or memory reporter problem. Print a message. + updateMainAndFooter(str, HIDE_FOOTER, "badInputWarning"); + } +} + +function reportAssertionFailure(aMsg) +{ + let debug = Cc["@mozilla.org/xpcom/debug;1"].getService(Ci.nsIDebug2); + if (debug.isDebugBuild) { + debug.assertion(aMsg, "false", "aboutMemory.js", 0); + } +} + +function debug(x) +{ + let section = appendElement(document.body, 'div', 'section'); + appendElementWithText(section, "div", "debug", JSON.stringify(x)); +} + +// --------------------------------------------------------------------------- + +function onUnload() +{ +} + +// --------------------------------------------------------------------------- + +// The <div> holding everything but the header and footer (if they're present). +// It's what is updated each time the page changes. +var gMain; + +// The <div> holding the footer. +var gFooter; + +// The "verbose" checkbox. +var gVerbose; + +// The "anonymize" checkbox. +var gAnonymize; + +// Values for the |aFooterAction| argument to updateTitleMainAndFooter. +var HIDE_FOOTER = 0; +var SHOW_FOOTER = 1; + +function updateTitleMainAndFooter(aTitleNote, aMsg, aFooterAction, aClassName) +{ + document.title = gPageName; + if (aTitleNote) { + document.title += " (" + aTitleNote + ")"; + } + + // Clear gMain by replacing it with an empty node. + let tmp = gMain.cloneNode(false); + gMain.parentNode.replaceChild(tmp, gMain); + gMain = tmp; + + gMain.classList.remove('hidden'); + gMain.classList.remove('verbose'); + gMain.classList.remove('non-verbose'); + if (gVerbose) { + gMain.classList.add(gVerbose.checked ? 'verbose' : 'non-verbose'); + } + + let msgElement; + if (aMsg) { + let className = "section" + if (aClassName) { + className = className + " " + aClassName; + } + msgElement = appendElementWithText(gMain, 'div', className, aMsg); + } + + switch (aFooterAction) { + case HIDE_FOOTER: gFooter.classList.add('hidden'); break; + case SHOW_FOOTER: gFooter.classList.remove('hidden'); break; + default: assert(false, "bad footer action in updateTitleMainAndFooter"); + } + return msgElement; +} + +function updateMainAndFooter(aMsg, aFooterAction, aClassName) +{ + return updateTitleMainAndFooter("", aMsg, aFooterAction, aClassName); +} + +function appendTextNode(aP, aText) +{ + let e = document.createTextNode(aText); + aP.appendChild(e); + return e; +} + +function appendElement(aP, aTagName, aClassName) +{ + let e = document.createElement(aTagName); + if (aClassName) { + e.className = aClassName; + } + aP.appendChild(e); + return e; +} + +function appendElementWithText(aP, aTagName, aClassName, aText) +{ + let e = appendElement(aP, aTagName, aClassName); + // Setting textContent clobbers existing children, but there are none. More + // importantly, it avoids creating a JS-land object for the node, saving + // memory. + e.textContent = aText; + return e; +} + +// --------------------------------------------------------------------------- + +const explicitTreeDescription = +"This tree covers explicit memory allocations by the application. It includes \ +\n\n\ +* allocations made at the operating system level (via calls to functions such as \ +VirtualAlloc, vm_allocate, and mmap), \ +\n\n\ +* allocations made at the heap allocation level (via functions such as malloc, \ +calloc, realloc, memalign, operator new, and operator new[]) that have not been \ +explicitly decommitted (i.e. evicted from memory and swap), and \ +\n\n\ +* where possible, the overhead of the heap allocator itself.\ +\n\n\ +It excludes memory that is mapped implicitly such as code and data segments, \ +and thread stacks. \ +\n\n\ +'explicit' is not guaranteed to cover every explicit allocation, but it does cover \ +most (including the entire heap), and therefore it is the single best number to \ +focus on when trying to reduce memory usage."; + +// --------------------------------------------------------------------------- + +function appendButton(aP, aTitle, aOnClick, aText, aId) +{ + let b = appendElementWithText(aP, "button", "", aText); + b.title = aTitle; + b.onclick = aOnClick; + if (aId) { + b.id = aId; + } + return b; +} + +function appendHiddenFileInput(aP, aId, aChangeListener) +{ + let input = appendElementWithText(aP, "input", "hidden", ""); + input.type = "file"; + input.id = aId; // used in testing + input.addEventListener("change", aChangeListener); + return input; +} + +function onLoad() +{ + // Generate the header. + + let header = appendElement(document.body, "div", "ancillary"); + + // A hidden file input element that can be invoked when necessary. + let fileInput1 = appendHiddenFileInput(header, "fileInput1", function() { + let file = this.files[0]; + let filename = file.mozFullPath; + updateAboutMemoryFromFile(filename); + }); + + // Ditto. + let fileInput2 = + appendHiddenFileInput(header, "fileInput2", function(e) { + let file = this.files[0]; + // First time around, we stash a copy of the filename and reinvoke. Second + // time around we do the diff and display. + if (!this.filename1) { + this.filename1 = file.mozFullPath; + + // e.skipClick is only true when testing -- it allows fileInput2's + // onchange handler to be re-called without having to go via the file + // picker. + if (!e.skipClick) { + this.click(); + } + } else { + let filename1 = this.filename1; + delete this.filename1; + updateAboutMemoryFromTwoFiles(filename1, file.mozFullPath); + } + }); + + const CuDesc = "Measure current memory reports and show."; + const LdDesc = "Load memory reports from file and show."; + const DfDesc = "Load memory report data from two files and show the " + + "difference."; + + const SvDesc = "Save memory reports to file."; + + const GCDesc = "Do a global garbage collection."; + const CCDesc = "Do a cycle collection."; + const MMDesc = "Send three \"heap-minimize\" notifications in a " + + "row. Each notification triggers a global garbage " + + "collection followed by a cycle collection, and causes the " + + "process to reduce memory usage in other ways, e.g. by " + + "flushing various caches."; + + const GCAndCCLogDesc = "Save garbage collection log and concise cycle " + + "collection log.\n" + + "WARNING: These logs may be large (>1GB)."; + const GCAndCCAllLogDesc = "Save garbage collection log and verbose cycle " + + "collection log.\n" + + "WARNING: These logs may be large (>1GB)."; + + const DMDEnabledDesc = "Analyze memory reports coverage and save the " + + "output to the temp directory.\n"; + const DMDDisabledDesc = "DMD is not running. Please re-start with $DMD and " + + "the other relevant environment variables set " + + "appropriately."; + + let ops = appendElement(header, "div", ""); + + let row1 = appendElement(ops, "div", "opsRow"); + + let labelDiv1 = + appendElementWithText(row1, "div", "opsRowLabel", "Show memory reports"); + let label1 = appendElementWithText(labelDiv1, "label", ""); + gVerbose = appendElement(label1, "input", ""); + gVerbose.type = "checkbox"; + gVerbose.id = "verbose"; // used for testing + appendTextNode(label1, "verbose"); + + const kEllipsis = "\u2026"; + + // The "measureButton" id is used for testing. + appendButton(row1, CuDesc, doMeasure, "Measure", "measureButton"); + appendButton(row1, LdDesc, () => fileInput1.click(), "Load" + kEllipsis); + appendButton(row1, DfDesc, () => fileInput2.click(), + "Load and diff" + kEllipsis); + + let row2 = appendElement(ops, "div", "opsRow"); + + let labelDiv2 = + appendElementWithText(row2, "div", "opsRowLabel", "Save memory reports"); + appendButton(row2, SvDesc, saveReportsToFile, "Measure and save" + kEllipsis); + + // XXX: this isn't a great place for this checkbox, but I can't think of + // anywhere better. + let label2 = appendElementWithText(labelDiv2, "label", ""); + gAnonymize = appendElement(label2, "input", ""); + gAnonymize.type = "checkbox"; + appendTextNode(label2, "anonymize"); + + let row3 = appendElement(ops, "div", "opsRow"); + + appendElementWithText(row3, "div", "opsRowLabel", "Free memory"); + appendButton(row3, GCDesc, doGC, "GC"); + appendButton(row3, CCDesc, doCC, "CC"); + appendButton(row3, MMDesc, doMMU, "Minimize memory usage"); + + let row4 = appendElement(ops, "div", "opsRow"); + + appendElementWithText(row4, "div", "opsRowLabel", "Save GC & CC logs"); + appendButton(row4, GCAndCCLogDesc, + saveGCLogAndConciseCCLog, "Save concise", 'saveLogsConcise'); + appendButton(row4, GCAndCCAllLogDesc, + saveGCLogAndVerboseCCLog, "Save verbose", 'saveLogsVerbose'); + + // Three cases here: + // - DMD is disabled (i.e. not built): don't show the button. + // - DMD is enabled but is not running: show the button, but disable it. + // - DMD is enabled and is running: show the button and enable it. + if (gMgr.isDMDEnabled) { + let row5 = appendElement(ops, "div", "opsRow"); + + appendElementWithText(row5, "div", "opsRowLabel", "Save DMD output"); + let enableButtons = gMgr.isDMDRunning; + + let dmdButton = + appendButton(row5, enableButtons ? DMDEnabledDesc : DMDDisabledDesc, + doDMD, "Save"); + dmdButton.disabled = !enableButtons; + } + + // Generate the main div, where content ("section" divs) will go. It's + // hidden at first. + + gMain = appendElement(document.body, 'div', ''); + gMain.id = 'mainDiv'; + + // Generate the footer. It's hidden at first. + + gFooter = appendElement(document.body, 'div', 'ancillary hidden'); + + let a = appendElementWithText(gFooter, "a", "option", + "Troubleshooting information"); + a.href = "about:support"; + + let legendText1 = "Click on a non-leaf node in a tree to expand ('++') " + + "or collapse ('--') its children."; + let legendText2 = "Hover the pointer over the name of a memory report " + + "to see a description of what it measures."; + + appendElementWithText(gFooter, "div", "legend", legendText1); + appendElementWithText(gFooter, "div", "legend hiddenOnMobile", legendText2); + + // See if we're loading from a file. (Because about:memory is a non-standard + // URL, location.search is undefined, so we have to use location.href + // instead.) + let search = location.href.split('?')[1]; + if (search) { + let searchSplit = search.split('&'); + for (let i = 0; i < searchSplit.length; i++) { + if (searchSplit[i].toLowerCase().startsWith('file=')) { + let filename = searchSplit[i].substring('file='.length); + updateAboutMemoryFromFile(decodeURIComponent(filename)); + return; + } + } + } +} + +// --------------------------------------------------------------------------- + +function doGC() +{ + Services.obs.notifyObservers(null, "child-gc-request", null); + Cu.forceGC(); + updateMainAndFooter("Garbage collection completed", HIDE_FOOTER); +} + +function doCC() +{ + Services.obs.notifyObservers(null, "child-cc-request", null); + window.QueryInterface(Ci.nsIInterfaceRequestor) + .getInterface(Ci.nsIDOMWindowUtils) + .cycleCollect(); + updateMainAndFooter("Cycle collection completed", HIDE_FOOTER); +} + +function doMMU() +{ + Services.obs.notifyObservers(null, "child-mmu-request", null); + gMgr.minimizeMemoryUsage( + () => updateMainAndFooter("Memory minimization completed", HIDE_FOOTER)); +} + +function doMeasure() +{ + updateAboutMemoryFromReporters(); +} + +function saveGCLogAndConciseCCLog() +{ + dumpGCLogAndCCLog(false); +} + +function saveGCLogAndVerboseCCLog() +{ + dumpGCLogAndCCLog(true); +} + +function doDMD() +{ + updateMainAndFooter("Saving memory reports and DMD output...", HIDE_FOOTER); + try { + let dumper = Cc["@mozilla.org/memory-info-dumper;1"] + .getService(Ci.nsIMemoryInfoDumper); + + dumper.dumpMemoryInfoToTempDir(/* identifier = */ "", + gAnonymize.checked, + /* minimize = */ false); + updateMainAndFooter("Saved memory reports and DMD reports analysis " + + "to the temp directory", + HIDE_FOOTER); + } catch (ex) { + updateMainAndFooter(ex.toString(), HIDE_FOOTER); + } +} + +function dumpGCLogAndCCLog(aVerbose) +{ + let dumper = Cc["@mozilla.org/memory-info-dumper;1"] + .getService(Ci.nsIMemoryInfoDumper); + + let inProgress = updateMainAndFooter("Saving logs...", HIDE_FOOTER); + let section = appendElement(gMain, 'div', "section"); + + function displayInfo(gcLog, ccLog, isParent) { + appendElementWithText(section, 'div', "", + "Saved GC log to " + gcLog.path); + + let ccLogType = aVerbose ? "verbose" : "concise"; + appendElementWithText(section, 'div', "", + "Saved " + ccLogType + " CC log to " + ccLog.path); + } + + dumper.dumpGCAndCCLogsToFile("", aVerbose, /* dumpChildProcesses = */ true, + { onDump: displayInfo, + onFinish: function() { + inProgress.remove(); + } + }); +} + +/** + * Top-level function that does the work of generating the page from the memory + * reporters. + */ +function updateAboutMemoryFromReporters() +{ + updateMainAndFooter("Measuring...", HIDE_FOOTER); + + try { + let processLiveMemoryReports = + function(aHandleReport, aDisplayReports) { + let handleReport = function(aProcess, aUnsafePath, aKind, aUnits, + aAmount, aDescription) { + aHandleReport(aProcess, aUnsafePath, aKind, aUnits, aAmount, + aDescription, /* presence = */ undefined); + } + + let displayReportsAndFooter = function() { + updateTitleMainAndFooter("live measurement", "", SHOW_FOOTER); + aDisplayReports(); + } + + gMgr.getReports(handleReport, null, displayReportsAndFooter, null, + gAnonymize.checked); + } + + // Process the reports from the live memory reporters. + appendAboutMemoryMain(processLiveMemoryReports, + gMgr.hasMozMallocUsableSize); + + } catch (ex) { + handleException(ex); + } +} + +// Increment this if the JSON format changes. +// +var gCurrentFileFormatVersion = 1; + + +/** + * Parse a string as JSON and extract the |memory_report| property if it has + * one, which indicates the string is from a crash dump. + * + * @param aStr + * The string. + * @return The extracted object. + */ +function parseAndUnwrapIfCrashDump(aStr) { + let obj = JSON.parse(aStr); + if (obj.memory_report !== undefined) { + // It looks like a crash dump. The memory reports should be in the + // |memory_report| property. + obj = obj.memory_report; + } + return obj; +} + +/** + * Populate about:memory using the data in the given JSON object. + * + * @param aObj + * An object that (hopefully!) conforms to the JSON schema used by + * nsIMemoryInfoDumper. + */ +function updateAboutMemoryFromJSONObject(aObj) +{ + try { + assertInput(aObj.version === gCurrentFileFormatVersion, + "data version number missing or doesn't match"); + assertInput(aObj.hasMozMallocUsableSize !== undefined, + "missing 'hasMozMallocUsableSize' property"); + assertInput(aObj.reports && aObj.reports instanceof Array, + "missing or non-array 'reports' property"); + + let processMemoryReportsFromFile = + function(aHandleReport, aDisplayReports) { + for (let i = 0; i < aObj.reports.length; i++) { + let r = aObj.reports[i]; + + // A hack: for a brief time (late in the FF26 and early in the FF27 + // cycle) we were dumping memory report files that contained reports + // whose path began with "redundant/". Such reports were ignored by + // about:memory. These reports are no longer produced, but some older + // builds are still floating around and producing files that contain + // them, so we need to still handle them (i.e. ignore them). This hack + // can be removed once FF26 and associated products (e.g. B2G 1.2) are + // no longer in common use. + if (!r.path.startsWith("redundant/")) { + aHandleReport(r.process, r.path, r.kind, r.units, r.amount, + r.description, r._presence); + } + } + aDisplayReports(); + } + appendAboutMemoryMain(processMemoryReportsFromFile, + aObj.hasMozMallocUsableSize); + } catch (ex) { + handleException(ex); + } +} + +/** + * Populate about:memory using the data in the given JSON string. + * + * @param aStr + * A string containing JSON data conforming to the schema used by + * nsIMemoryReporterManager::dumpReports. + */ +function updateAboutMemoryFromJSONString(aStr) +{ + try { + let obj = parseAndUnwrapIfCrashDump(aStr); + updateAboutMemoryFromJSONObject(obj); + } catch (ex) { + handleException(ex); + } +} + +/** + * Loads the contents of a file into a string and passes that to a callback. + * + * @param aFilename + * The name of the file being read from. + * @param aTitleNote + * A description to put in the page title upon completion. + * @param aFn + * The function to call and pass the read string to upon completion. + */ +function loadMemoryReportsFromFile(aFilename, aTitleNote, aFn) +{ + updateMainAndFooter("Loading...", HIDE_FOOTER); + + try { + let reader = new FileReader(); + reader.onerror = () => { throw new Error("FileReader.onerror"); }; + reader.onabort = () => { throw new Error("FileReader.onabort"); }; + reader.onload = (aEvent) => { + // Clear "Loading..." from above. + updateTitleMainAndFooter(aTitleNote, "", SHOW_FOOTER); + aFn(aEvent.target.result); + }; + + // If it doesn't have a .gz suffix, read it as a (legacy) ungzipped file. + if (!aFilename.endsWith(".gz")) { + reader.readAsText(File.createFromFileName(aFilename)); + return; + } + + // Read compressed gzip file. + let converter = new nsGzipConverter(); + converter.asyncConvertData("gzip", "uncompressed", { + data: [], + onStartRequest: function(aR, aC) {}, + onDataAvailable: function(aR, aC, aStream, aO, aCount) { + let bi = new nsBinaryStream(aStream); + this.data.push(bi.readBytes(aCount)); + }, + onStopRequest: function(aR, aC, aStatusCode) { + try { + if (!Components.isSuccessCode(aStatusCode)) { + throw new Components.Exception("Error while reading gzip file", aStatusCode); + } + reader.readAsText(new Blob(this.data)); + } catch (ex) { + handleException(ex); + } + } + }, null); + + let file = new nsFile(aFilename); + let fileChan = NetUtil.newChannel({ + uri: Services.io.newFileURI(file), + loadUsingSystemPrincipal: true + }); + fileChan.asyncOpen2(converter); + + } catch (ex) { + handleException(ex); + } +} + +/** + * Like updateAboutMemoryFromReporters(), but gets its data from a file instead + * of the memory reporters. + * + * @param aFilename + * The name of the file being read from. The expected format of the + * file's contents is described in a comment in nsIMemoryInfoDumper.idl. + */ +function updateAboutMemoryFromFile(aFilename) +{ + loadMemoryReportsFromFile(aFilename, /* title note */ aFilename, + updateAboutMemoryFromJSONString); +} + +/** + * Like updateAboutMemoryFromFile(), but gets its data from a two files and + * diffs them. + * + * @param aFilename1 + * The name of the first file being read from. + * @param aFilename2 + * The name of the first file being read from. + */ +function updateAboutMemoryFromTwoFiles(aFilename1, aFilename2) +{ + let titleNote = "diff of " + aFilename1 + " and " + aFilename2; + loadMemoryReportsFromFile(aFilename1, titleNote, function(aStr1) { + loadMemoryReportsFromFile(aFilename2, titleNote, function(aStr2) { + try { + let obj1 = parseAndUnwrapIfCrashDump(aStr1); + let obj2 = parseAndUnwrapIfCrashDump(aStr2); + gIsDiff = true; + updateAboutMemoryFromJSONObject(diffJSONObjects(obj1, obj2)); + gIsDiff = false; + } catch (ex) { + handleException(ex); + } + }); + }); +} + +// --------------------------------------------------------------------------- + +// Something unlikely to appear in a process name. +var kProcessPathSep = "^:^:^"; + +// Short for "diff report". +function DReport(aKind, aUnits, aAmount, aDescription, aNMerged, aPresence) +{ + this._kind = aKind; + this._units = aUnits; + this._amount = aAmount; + this._description = aDescription; + this._nMerged = aNMerged; + if (aPresence !== undefined) { + this._presence = aPresence; + } +} + +DReport.prototype = { + assertCompatible: function(aKind, aUnits) + { + assert(this._kind == aKind, "Mismatched kinds"); + assert(this._units == aUnits, "Mismatched units"); + + // We don't check that the "description" properties match. This is because + // on Linux we can get cases where the paths are the same but the + // descriptions differ, like this: + // + // "path": "size/other-files/icon-theme.cache/[r--p]", + // "description": "/usr/share/icons/gnome/icon-theme.cache (read-only, not executable, private)" + // + // "path": "size/other-files/icon-theme.cache/[r--p]" + // "description": "/usr/share/icons/hicolor/icon-theme.cache (read-only, not executable, private)" + // + // In those cases, we just use the description from the first-encountered + // one, which is what about:memory also does. + // (Note: reports with those paths are no longer generated, but allowing + // the descriptions to differ seems reasonable.) + }, + + merge: function(aJr) { + this.assertCompatible(aJr.kind, aJr.units); + this._amount += aJr.amount; + this._nMerged++; + }, + + toJSON: function(aProcess, aPath, aAmount) { + return { + process: aProcess, + path: aPath, + kind: this._kind, + units: this._units, + amount: aAmount, + description: this._description, + _presence: this._presence + }; + } +}; + +// Constants that indicate if a DReport was present only in one of the data +// sets, or had to be added for balance. +DReport.PRESENT_IN_FIRST_ONLY = 1; +DReport.PRESENT_IN_SECOND_ONLY = 2; +DReport.ADDED_FOR_BALANCE = 3; + +/** + * Make a report map, which has combined path+process strings for keys, and + * DReport objects for values. + * + * @param aJSONReports + * The |reports| field of a JSON object. + * @return The constructed report map. + */ +function makeDReportMap(aJSONReports) +{ + let dreportMap = {}; + for (let i = 0; i < aJSONReports.length; i++) { + let jr = aJSONReports[i]; + + assert(jr.process !== undefined, "Missing process"); + assert(jr.path !== undefined, "Missing path"); + assert(jr.kind !== undefined, "Missing kind"); + assert(jr.units !== undefined, "Missing units"); + assert(jr.amount !== undefined, "Missing amount"); + assert(jr.description !== undefined, "Missing description"); + + // Strip out some non-deterministic stuff that prevents clean diffs. + // Ideally the memory reports themselves would contain information about + // which parts of the the process and path need to be stripped -- saving us + // from hardwiring knowledge of specific reporters here -- but we have no + // mechanism for that. (Any future redesign of how memory reporters work + // should include such a mechanism.) + + // Strip PIDs: + // - pid 123 + // - pid=123 + let pidRegex = /pid([ =])\d+/g; + let pidSubst = "pid$1NNN"; + let process = jr.process.replace(pidRegex, pidSubst); + let path = jr.path.replace(pidRegex, pidSubst); + + // Strip addresses: + // - .../js-zone(0x12345678)/... + // - .../zone(0x12345678)/... + // - .../worker(<URL>, 0x12345678)/... + path = path.replace(/zone\(0x[0-9A-Fa-f]+\)\//, "zone(0xNNN)/"); + path = path.replace(/\/worker\((.+), 0x[0-9A-Fa-f]+\)\//, + "/worker($1, 0xNNN)/"); + + // Strip top window IDs: + // - explicit/window-objects/top(<URL>, id=123)/... + path = path.replace(/^(explicit\/window-objects\/top\(.*, id=)\d+\)/, + "$1NNN)"); + + // Strip null principal UUIDs (but not other UUIDs, because they may be + // deterministic, such as those used by add-ons). + path = path.replace( + /moz-nullprincipal:{........-....-....-....-............}/g, + "moz-nullprincipal:{NNNNNNNN-NNNN-NNNN-NNNN-NNNNNNNNNNNN}"); + + // Normalize omni.ja! paths. + path = path.replace(/jar:file:\\\\\\(.+)\\omni.ja!/, + "jar:file:\\\\\\...\\omni.ja!"); + + let processPath = process + kProcessPathSep + path; + let rOld = dreportMap[processPath]; + if (rOld === undefined) { + dreportMap[processPath] = + new DReport(jr.kind, jr.units, jr.amount, jr.description, 1, undefined); + } else { + rOld.merge(jr); + } + } + return dreportMap; +} + +// Return a new dreportMap which is the diff of two dreportMaps. Empties +// aDReportMap2 along the way. +function diffDReportMaps(aDReportMap1, aDReportMap2) +{ + let result = {}; + + for (let processPath in aDReportMap1) { + let r1 = aDReportMap1[processPath]; + let r2 = aDReportMap2[processPath]; + let r2_amount, r2_nMerged; + let presence; + if (r2 !== undefined) { + r1.assertCompatible(r2._kind, r2._units); + r2_amount = r2._amount; + r2_nMerged = r2._nMerged; + delete aDReportMap2[processPath]; + presence = undefined; // represents that it's present in both + } else { + r2_amount = 0; + r2_nMerged = 0; + presence = DReport.PRESENT_IN_FIRST_ONLY; + } + result[processPath] = + new DReport(r1._kind, r1._units, r2_amount - r1._amount, r1._description, + Math.max(r1._nMerged, r2_nMerged), presence); + } + + for (let processPath in aDReportMap2) { + let r2 = aDReportMap2[processPath]; + result[processPath] = new DReport(r2._kind, r2._units, r2._amount, + r2._description, r2._nMerged, + DReport.PRESENT_IN_SECOND_ONLY); + } + + return result; +} + +function makeJSONReports(aDReportMap) +{ + let reports = []; + for (let processPath in aDReportMap) { + let r = aDReportMap[processPath]; + if (r._amount !== 0) { + // If _nMerged > 1, we give the full (aggregated) amount in the first + // copy, and then use amount=0 in the remainder. When viewed in + // about:memory, this shows up as an entry with a "[2]"-style suffix + // and the correct amount. + let split = processPath.split(kProcessPathSep); + assert(split.length >= 2); + let process = split.shift(); + let path = split.join(); + reports.push(r.toJSON(process, path, r._amount)); + for (let i = 1; i < r._nMerged; i++) { + reports.push(r.toJSON(process, path, 0)); + } + } + } + + return reports; +} + +// Diff two JSON objects holding memory reports. +function diffJSONObjects(aJson1, aJson2) +{ + function simpleProp(aProp) + { + assert(aJson1[aProp] !== undefined && aJson1[aProp] === aJson2[aProp], + aProp + " properties don't match"); + return aJson1[aProp]; + } + + return { + version: simpleProp("version"), + + hasMozMallocUsableSize: simpleProp("hasMozMallocUsableSize"), + + reports: makeJSONReports(diffDReportMaps(makeDReportMap(aJson1.reports), + makeDReportMap(aJson2.reports))) + }; +} + +// --------------------------------------------------------------------------- + +// |PColl| is short for "process collection". +function PColl() +{ + this._trees = {}; + this._degenerates = {}; + this._heapTotal = 0; +} + +/** + * Processes reports (whether from reporters or from a file) and append the + * main part of the page. + * + * @param aProcessReports + * Function that extracts the memory reports from the reporters or from + * file. + * @param aHasMozMallocUsableSize + * Boolean indicating if moz_malloc_usable_size works. + */ +function appendAboutMemoryMain(aProcessReports, aHasMozMallocUsableSize) +{ + let pcollsByProcess = {}; + + function handleReport(aProcess, aUnsafePath, aKind, aUnits, aAmount, + aDescription, aPresence) + { + if (aUnsafePath.startsWith("explicit/")) { + assertInput(aKind === KIND_HEAP || aKind === KIND_NONHEAP, + "bad explicit kind"); + assertInput(aUnits === UNITS_BYTES, "bad explicit units"); + } + + assert(aPresence === undefined || + aPresence == DReport.PRESENT_IN_FIRST_ONLY || + aPresence == DReport.PRESENT_IN_SECOND_ONLY, + "bad presence"); + + let process = aProcess === "" ? gUnnamedProcessStr : aProcess; + let unsafeNames = aUnsafePath.split('/'); + let unsafeName0 = unsafeNames[0]; + let isDegenerate = unsafeNames.length === 1; + + // Get the PColl table for the process, creating it if necessary. + let pcoll = pcollsByProcess[process]; + if (!pcollsByProcess[process]) { + pcoll = pcollsByProcess[process] = new PColl(); + } + + // Get the root node, creating it if necessary. + let psubcoll = isDegenerate ? pcoll._degenerates : pcoll._trees; + let t = psubcoll[unsafeName0]; + if (!t) { + t = psubcoll[unsafeName0] = + new TreeNode(unsafeName0, aUnits, isDegenerate); + } + + if (!isDegenerate) { + // Add any missing nodes in the tree implied by aUnsafePath, and fill in + // the properties that we can with a top-down traversal. + for (let i = 1; i < unsafeNames.length; i++) { + let unsafeName = unsafeNames[i]; + let u = t.findKid(unsafeName); + if (!u) { + u = new TreeNode(unsafeName, aUnits, isDegenerate); + if (!t._kids) { + t._kids = []; + } + t._kids.push(u); + } + t = u; + } + + // Update the heap total if necessary. + if (unsafeName0 === "explicit" && aKind == KIND_HEAP) { + pcollsByProcess[process]._heapTotal += aAmount; + } + } + + if (t._amount) { + // Duplicate! Sum the values and mark it as a dup. + t._amount += aAmount; + t._nMerged = t._nMerged ? t._nMerged + 1 : 2; + assert(t._presence === aPresence, "presence mismatch"); + } else { + // New leaf node. Fill in extra node details from the report. + t._amount = aAmount; + t._description = aDescription; + if (aPresence !== undefined) { + t._presence = aPresence; + } + } + } + + function displayReports() + { + // Sort the processes. + let processes = Object.keys(pcollsByProcess); + processes.sort(function(aProcessA, aProcessB) { + assert(aProcessA != aProcessB, + "Elements of Object.keys() should be unique, but " + + "saw duplicate '" + aProcessA + "' elem."); + + // Always put the main process first. + if (aProcessA == gUnnamedProcessStr) { + return -1; + } + if (aProcessB == gUnnamedProcessStr) { + return 1; + } + + // Then sort by resident size. + let nodeA = pcollsByProcess[aProcessA]._degenerates['resident']; + let nodeB = pcollsByProcess[aProcessB]._degenerates['resident']; + let residentA = nodeA ? nodeA._amount : -1; + let residentB = nodeB ? nodeB._amount : -1; + + if (residentA > residentB) { + return -1; + } + if (residentA < residentB) { + return 1; + } + + // Then sort by process name. + if (aProcessA < aProcessB) { + return -1; + } + if (aProcessA > aProcessB) { + return 1; + } + + return 0; + }); + + // Generate output for each process. + for (let i = 0; i < processes.length; i++) { + let process = processes[i]; + let section = appendElement(gMain, 'div', 'section'); + + appendProcessAboutMemoryElements(section, i, process, + pcollsByProcess[process]._trees, + pcollsByProcess[process]._degenerates, + pcollsByProcess[process]._heapTotal, + aHasMozMallocUsableSize); + } + } + + aProcessReports(handleReport, displayReports); +} + +// --------------------------------------------------------------------------- + +// There are two kinds of TreeNode. +// - Leaf TreeNodes correspond to reports. +// - Non-leaf TreeNodes are just scaffolding nodes for the tree; their values +// are derived from their children. +// Some trees are "degenerate", i.e. they contain a single node, i.e. they +// correspond to a report whose path has no '/' separators. +function TreeNode(aUnsafeName, aUnits, aIsDegenerate) +{ + this._units = aUnits; + this._unsafeName = aUnsafeName; + if (aIsDegenerate) { + this._isDegenerate = true; + } + + // Leaf TreeNodes have these properties added immediately after construction: + // - _amount + // - _description + // - _nMerged (only defined if > 1) + // - _presence (only defined if value is PRESENT_IN_{FIRST,SECOND}_ONLY) + // + // Non-leaf TreeNodes have these properties added later: + // - _kids + // - _amount + // - _description + // - _hideKids (only defined if true) + // - _maxAbsDescendant (on-demand, only when gIsDiff is set) +} + +TreeNode.prototype = { + findKid: function(aUnsafeName) { + if (this._kids) { + for (let i = 0; i < this._kids.length; i++) { + if (this._kids[i]._unsafeName === aUnsafeName) { + return this._kids[i]; + } + } + } + return undefined; + }, + + // When gIsDiff is false, tree operations -- sorting and determining if a + // sub-tree is significant -- are straightforward. But when gIsDiff is true, + // the combination of positive and negative values within a tree complicates + // things. So for a non-leaf node, instead of just looking at _amount, we + // instead look at the maximum absolute value of the node and all of its + // descendants. + maxAbsDescendant: function() { + if (!this._kids) { + // No kids? Just return the absolute value of the amount. + return Math.abs(this._amount); + } + + if ('_maxAbsDescendant' in this) { + // We've computed this before? Return the saved value. + return this._maxAbsDescendant; + } + + // Compute the maximum absolute value of all descendants. + let max = Math.abs(this._amount); + for (let i = 0; i < this._kids.length; i++) { + max = Math.max(max, this._kids[i].maxAbsDescendant()); + } + this._maxAbsDescendant = max; + return max; + }, + + toString: function() { + switch (this._units) { + case UNITS_BYTES: return formatBytes(this._amount); + case UNITS_COUNT: + case UNITS_COUNT_CUMULATIVE: return formatInt(this._amount); + case UNITS_PERCENTAGE: return formatPercentage(this._amount); + default: + throw "Invalid memory report(s): bad units in TreeNode.toString"; + } + } +}; + +// Sort TreeNodes first by size, then by name. The latter is important for the +// about:memory tests, which need a predictable ordering of reporters which +// have the same amount. +TreeNode.compareAmounts = function(aA, aB) { + let a, b; + if (gIsDiff) { + a = aA.maxAbsDescendant(); + b = aB.maxAbsDescendant(); + } else { + a = aA._amount; + b = aB._amount; + } + if (a > b) { + return -1; + } + if (a < b) { + return 1; + } + return TreeNode.compareUnsafeNames(aA, aB); +}; + +TreeNode.compareUnsafeNames = function(aA, aB) { + return aA._unsafeName.localeCompare(aB._unsafeName); +}; + + +/** + * Fill in the remaining properties for the specified tree in a bottom-up + * fashion. + * + * @param aRoot + * The tree root. + */ +function fillInTree(aRoot) +{ + // Fill in the remaining properties bottom-up. + function fillInNonLeafNodes(aT) + { + if (!aT._kids) { + // Leaf node. Has already been filled in. + + } else if (aT._kids.length === 1 && aT != aRoot) { + // Non-root, non-leaf node with one child. Merge the child with the node + // to avoid redundant entries. + let kid = aT._kids[0]; + let kidBytes = fillInNonLeafNodes(kid); + aT._unsafeName += '/' + kid._unsafeName; + if (kid._kids) { + aT._kids = kid._kids; + } else { + delete aT._kids; + } + aT._amount = kidBytes; + aT._description = kid._description; + if (kid._nMerged !== undefined) { + aT._nMerged = kid._nMerged + } + assert(!aT._hideKids && !kid._hideKids, "_hideKids set when merging"); + + } else { + // Non-leaf node with multiple children. Derive its _amount and + // _description entirely from its children... + let kidsBytes = 0; + for (let i = 0; i < aT._kids.length; i++) { + kidsBytes += fillInNonLeafNodes(aT._kids[i]); + } + + // ... except in one special case. When diffing two memory report sets, + // if one set has a node with children and the other has the same node + // but without children -- e.g. the first has "a/b/c" and "a/b/d", but + // the second only has "a/b" -- we need to add a fake node "a/b/(fake)" + // to the second to make the trees comparable. It's ugly, but it works. + if (aT._amount !== undefined && + (aT._presence === DReport.PRESENT_IN_FIRST_ONLY || + aT._presence === DReport.PRESENT_IN_SECOND_ONLY)) { + aT._amount += kidsBytes; + let fake = new TreeNode('(fake child)', aT._units); + fake._presence = DReport.ADDED_FOR_BALANCE; + fake._amount = aT._amount - kidsBytes; + aT._kids.push(fake); + delete aT._presence; + } else { + assert(aT._amount === undefined, + "_amount already set for non-leaf node") + aT._amount = kidsBytes; + } + aT._description = "The sum of all entries below this one."; + } + return aT._amount; + } + + // cannotMerge is set because don't want to merge into a tree's root node. + fillInNonLeafNodes(aRoot); +} + +/** + * Compute the "heap-unclassified" value and insert it into the "explicit" + * tree. + * + * @param aT + * The "explicit" tree. + * @param aHeapAllocatedNode + * The "heap-allocated" tree node. + * @param aHeapTotal + * The sum of all explicit HEAP reports for this process. + * @return A boolean indicating if "heap-allocated" is known for the process. + */ +function addHeapUnclassifiedNode(aT, aHeapAllocatedNode, aHeapTotal) +{ + if (aHeapAllocatedNode === undefined) + return false; + + if (aT.findKid("heap-unclassified")) { + // heap-unclassified was already calculated, there's nothing left to do. + // This can happen when memory reports are exported from areweslimyet.com. + return true; + } + + assert(aHeapAllocatedNode._isDegenerate, "heap-allocated is not degenerate"); + let heapAllocatedBytes = aHeapAllocatedNode._amount; + let heapUnclassifiedT = new TreeNode("heap-unclassified", UNITS_BYTES); + heapUnclassifiedT._amount = heapAllocatedBytes - aHeapTotal; + heapUnclassifiedT._description = + "Memory not classified by a more specific report. This includes " + + "slop bytes due to internal fragmentation in the heap allocator " + + "(caused when the allocator rounds up request sizes)."; + aT._kids.push(heapUnclassifiedT); + aT._amount += heapUnclassifiedT._amount; + return true; +} + +/** + * Sort all kid nodes from largest to smallest, and insert aggregate nodes + * where appropriate. + * + * @param aTotalBytes + * The size of the tree's root node. + * @param aT + * The tree. + */ +function sortTreeAndInsertAggregateNodes(aTotalBytes, aT) +{ + const kSignificanceThresholdPerc = 1; + + function isInsignificant(aT) + { + if (gVerbose.checked) + return false; + + let perc = gIsDiff + ? 100 * aT.maxAbsDescendant() / Math.abs(aTotalBytes) + : 100 * aT._amount / aTotalBytes; + return perc < kSignificanceThresholdPerc; + } + + if (!aT._kids) { + return; + } + + aT._kids.sort(TreeNode.compareAmounts); + + // If the first child is insignificant, they all are, and there's no point + // creating an aggregate node that lacks siblings. Just set the parent's + // _hideKids property and process all children. + if (isInsignificant(aT._kids[0])) { + aT._hideKids = true; + for (let i = 0; i < aT._kids.length; i++) { + sortTreeAndInsertAggregateNodes(aTotalBytes, aT._kids[i]); + } + return; + } + + // Look at all children except the last one. + let i; + for (i = 0; i < aT._kids.length - 1; i++) { + if (isInsignificant(aT._kids[i])) { + // This child is below the significance threshold. If there are other + // (smaller) children remaining, move them under an aggregate node. + let i0 = i; + let nAgg = aT._kids.length - i0; + // Create an aggregate node. Inherit units from the parent; everything + // in the tree should have the same units anyway (we test this later). + let aggT = new TreeNode("(" + nAgg + " tiny)", aT._units); + aggT._kids = []; + let aggBytes = 0; + for ( ; i < aT._kids.length; i++) { + aggBytes += aT._kids[i]._amount; + aggT._kids.push(aT._kids[i]); + } + aggT._hideKids = true; + aggT._amount = aggBytes; + aggT._description = + nAgg + " sub-trees that are below the " + kSignificanceThresholdPerc + + "% significance threshold."; + aT._kids.splice(i0, nAgg, aggT); + aT._kids.sort(TreeNode.compareAmounts); + + // Process the moved children. + for (i = 0; i < aggT._kids.length; i++) { + sortTreeAndInsertAggregateNodes(aTotalBytes, aggT._kids[i]); + } + return; + } + + sortTreeAndInsertAggregateNodes(aTotalBytes, aT._kids[i]); + } + + // The first n-1 children were significant. Don't consider if the last child + // is significant; there's no point creating an aggregate node that only has + // one child. Just process it. + sortTreeAndInsertAggregateNodes(aTotalBytes, aT._kids[i]); +} + +// Global variable indicating if we've seen any invalid values for this +// process; it holds the unsafePaths of any such reports. It is reset for +// each new process. +var gUnsafePathsWithInvalidValuesForThisProcess = []; + +function appendWarningElements(aP, aHasKnownHeapAllocated, + aHasMozMallocUsableSize) +{ + if (!aHasKnownHeapAllocated && !aHasMozMallocUsableSize) { + appendElementWithText(aP, "p", "", + "WARNING: the 'heap-allocated' memory reporter and the " + + "moz_malloc_usable_size() function do not work for this platform " + + "and/or configuration. This means that 'heap-unclassified' is not " + + "shown and the 'explicit' tree shows much less memory than it should.\n\n"); + + } else if (!aHasKnownHeapAllocated) { + appendElementWithText(aP, "p", "", + "WARNING: the 'heap-allocated' memory reporter does not work for this " + + "platform and/or configuration. This means that 'heap-unclassified' " + + "is not shown and the 'explicit' tree shows less memory than it should.\n\n"); + + } else if (!aHasMozMallocUsableSize) { + appendElementWithText(aP, "p", "", + "WARNING: the moz_malloc_usable_size() function does not work for " + + "this platform and/or configuration. This means that much of the " + + "heap-allocated memory is not measured by individual memory reporters " + + "and so will fall under 'heap-unclassified'.\n\n"); + } + + if (gUnsafePathsWithInvalidValuesForThisProcess.length > 0) { + let div = appendElement(aP, "div"); + appendElementWithText(div, "p", "", + "WARNING: the following values are negative or unreasonably large.\n"); + + let ul = appendElement(div, "ul"); + for (let i = 0; + i < gUnsafePathsWithInvalidValuesForThisProcess.length; + i++) + { + appendTextNode(ul, " "); + appendElementWithText(ul, "li", "", + flipBackslashes(gUnsafePathsWithInvalidValuesForThisProcess[i]) + "\n"); + } + + appendElementWithText(div, "p", "", + "This indicates a defect in one or more memory reporters. The " + + "invalid values are highlighted.\n\n"); + gUnsafePathsWithInvalidValuesForThisProcess = []; // reset for the next process + } +} + +/** + * Appends the about:memory elements for a single process. + * + * @param aP + * The parent DOM node. + * @param aN + * The number of the process, starting at 0. + * @param aProcess + * The name of the process. + * @param aTrees + * The table of non-degenerate trees for this process. + * @param aDegenerates + * The table of degenerate trees for this process. + * @param aHasMozMallocUsableSize + * Boolean indicating if moz_malloc_usable_size works. + * @return The generated text. + */ +function appendProcessAboutMemoryElements(aP, aN, aProcess, aTrees, + aDegenerates, aHeapTotal, + aHasMozMallocUsableSize) +{ + const kUpwardsArrow = "\u2191", + kDownwardsArrow = "\u2193"; + + let appendLink = function(aHere, aThere, aArrow) { + let link = appendElementWithText(aP, "a", "upDownArrow", aArrow); + link.href = "#" + aThere + aN; + link.id = aHere + aN; + link.title = "Go to the " + aThere + " of " + aProcess; + link.style = "text-decoration: none"; + + // This jumps to the anchor without the page location getting the anchor + // name tacked onto its end, which is what happens with a vanilla link. + link.addEventListener("click", function(event) { + document.documentElement.scrollTop = + document.querySelector(event.target.href).offsetTop; + event.preventDefault(); + }, false); + + // This gives nice spacing when we copy and paste. + appendElementWithText(aP, "span", "", "\n"); + } + + appendElementWithText(aP, "h1", "", aProcess); + appendLink("start", "end", kDownwardsArrow); + + // We'll fill this in later. + let warningsDiv = appendElement(aP, "div", "accuracyWarning"); + + // The explicit tree. + let hasExplicitTree; + let hasKnownHeapAllocated; + { + let treeName = "explicit"; + let t = aTrees[treeName]; + if (t) { + let pre = appendSectionHeader(aP, "Explicit Allocations"); + hasExplicitTree = true; + 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); + sortTreeAndInsertAggregateNodes(t._amount, t); + t._description = explicitTreeDescription; + appendTreeElements(pre, t, aProcess, ""); + delete aTrees[treeName]; + } + appendTextNode(aP, "\n"); // gives nice spacing when we copy and paste + } + + // Fill in and sort all the non-degenerate other trees. + let otherTrees = []; + for (let unsafeName in aTrees) { + let t = aTrees[unsafeName]; + assert(!t._isDegenerate, "tree is degenerate"); + fillInTree(t); + sortTreeAndInsertAggregateNodes(t._amount, t); + otherTrees.push(t); + } + otherTrees.sort(TreeNode.compareUnsafeNames); + + // Get the length of the longest root value among the degenerate other trees, + // and sort them as well. + let otherDegenerates = []; + let maxStringLength = 0; + for (let unsafeName in aDegenerates) { + let t = aDegenerates[unsafeName]; + assert(t._isDegenerate, "tree is not degenerate"); + let length = t.toString().length; + if (length > maxStringLength) { + maxStringLength = length; + } + otherDegenerates.push(t); + } + otherDegenerates.sort(TreeNode.compareUnsafeNames); + + // Now generate the elements, putting non-degenerate trees first. + let pre = appendSectionHeader(aP, "Other Measurements"); + for (let i = 0; i < otherTrees.length; i++) { + let t = otherTrees[i]; + appendTreeElements(pre, t, aProcess, ""); + appendTextNode(pre, "\n"); // blank lines after non-degenerate trees + } + for (let i = 0; i < otherDegenerates.length; i++) { + let t = otherDegenerates[i]; + let padText = pad("", maxStringLength - t.toString().length, ' '); + appendTreeElements(pre, t, aProcess, padText); + } + appendTextNode(aP, "\n"); // gives nice spacing when we copy and paste + + // Add any warnings about inaccuracies in the "explicit" tree due to platform + // limitations. These must be computed after generating all the text. The + // newlines give nice spacing if we copy+paste into a text buffer. + if (hasExplicitTree) { + appendWarningElements(warningsDiv, hasKnownHeapAllocated, + aHasMozMallocUsableSize); + } + + appendElementWithText(aP, "h3", "", "End of " + aProcess); + appendLink("end", "start", kUpwardsArrow); +} + +/** + * Determines if a number has a negative sign when converted to a string. + * Works even for -0. + * + * @param aN + * The number. + * @return A boolean. + */ +function hasNegativeSign(aN) +{ + if (aN === 0) { // this succeeds for 0 and -0 + return 1 / aN === -Infinity; // this succeeds for -0 + } + return aN < 0; +} + +/** + * Formats an int as a human-readable string. + * + * @param aN + * The integer to format. + * @param aExtra + * An extra string to tack onto the end. + * @return A human-readable string representing the int. + * + * Note: building an array of chars and converting that to a string with + * Array.join at the end is more memory efficient than using string + * concatenation. See bug 722972 for details. + */ +function formatInt(aN, aExtra) +{ + let neg = false; + if (hasNegativeSign(aN)) { + neg = true; + aN = -aN; + } + let s = []; + while (true) { + let k = aN % 1000; + aN = Math.floor(aN / 1000); + if (aN > 0) { + if (k < 10) { + s.unshift(",00", k); + } else if (k < 100) { + s.unshift(",0", k); + } else { + s.unshift(",", k); + } + } else { + s.unshift(k); + break; + } + } + if (neg) { + s.unshift("-"); + } + if (aExtra) { + s.push(aExtra); + } + return s.join(""); +} + +/** + * Converts a byte count to an appropriate string representation. + * + * @param aBytes + * The byte count. + * @return The string representation. + */ +function formatBytes(aBytes) +{ + let unit = gVerbose.checked ? " B" : " MB"; + + let s; + if (gVerbose.checked) { + s = formatInt(aBytes, unit); + } else { + let mbytes = (aBytes / (1024 * 1024)).toFixed(2); + let a = String(mbytes).split("."); + // If the argument to formatInt() is -0, it will print the negative sign. + s = formatInt(Number(a[0])) + "." + a[1] + unit; + } + return s; +} + +/** + * Converts a percentage to an appropriate string representation. + * + * @param aPerc100x + * The percentage, multiplied by 100 (see nsIMemoryReporter). + * @return The string representation + */ +function formatPercentage(aPerc100x) +{ + return (aPerc100x / 100).toFixed(2) + "%"; +} + +/** + * Right-justifies a string in a field of a given width, padding as necessary. + * + * @param aS + * The string. + * @param aN + * The field width. + * @param aC + * The char used to pad. + * @return The string representation. + */ +function pad(aS, aN, aC) +{ + let padding = ""; + let n2 = aN - aS.length; + for (let i = 0; i < n2; i++) { + padding += aC; + } + return padding + aS; +} + +// There's a subset of the Unicode "light" box-drawing chars that is widely +// implemented in terminals, and this code sticks to that subset to maximize +// the chance that copying and pasting about:memory output to a terminal will +// work correctly. +const kHorizontal = "\u2500", + kVertical = "\u2502", + kUpAndRight = "\u2514", + kUpAndRight_Right_Right = "\u2514\u2500\u2500", + kVerticalAndRight = "\u251c", + kVerticalAndRight_Right_Right = "\u251c\u2500\u2500", + kVertical_Space_Space = "\u2502 "; + +const kNoKidsSep = " \u2500\u2500 ", + kHideKidsSep = " ++ ", + kShowKidsSep = " -- "; + +function appendMrNameSpan(aP, aDescription, aUnsafeName, aIsInvalid, aNMerged, + aPresence) +{ + let safeName = flipBackslashes(aUnsafeName); + if (!aIsInvalid && !aNMerged && !aPresence) { + safeName += "\n"; + } + let nameSpan = appendElementWithText(aP, "span", "mrName", safeName); + nameSpan.title = aDescription; + + if (aIsInvalid) { + let noteText = " [?!]"; + if (!aNMerged) { + noteText += "\n"; + } + let noteSpan = appendElementWithText(aP, "span", "mrNote", noteText); + noteSpan.title = + "Warning: this value is invalid and indicates a bug in one or more " + + "memory reporters. "; + } + + if (aNMerged) { + let noteText = " [" + aNMerged + "]"; + if (!aPresence) { + noteText += "\n"; + } + let noteSpan = appendElementWithText(aP, "span", "mrNote", noteText); + noteSpan.title = + "This value is the sum of " + aNMerged + + " memory reports that all have the same path."; + } + + if (aPresence) { + let c, title; + switch (aPresence) { + case DReport.PRESENT_IN_FIRST_ONLY: + c = '-'; + title = "This value was only present in the first set of memory reports."; + break; + case DReport.PRESENT_IN_SECOND_ONLY: + c = '+'; + title = "This value was only present in the second set of memory reports."; + break; + case DReport.ADDED_FOR_BALANCE: + c = '!'; + title = "One of the sets of memory reports lacked children for this " + + "node's parent. This is a fake child node added to make the " + + "two memory sets comparable."; + break; + default: assert(false, "bad presence"); + break; + } + let noteSpan = appendElementWithText(aP, "span", "mrNote", + " [" + c + "]\n"); + noteSpan.title = title; + } +} + +// This is used to record the (safe) IDs of which sub-trees have been manually +// expanded (marked as true) and collapsed (marked as false). It's used to +// replicate the collapsed/expanded state when the page is updated. It can end +// up holding IDs of nodes that no longer exist, e.g. for compartments that +// have been closed. This doesn't seem like a big deal, because the number is +// limited by the number of entries the user has changed from their original +// state. +var gShowSubtreesBySafeTreeId = {}; + +function assertClassListContains(e, className) { + assert(e, "undefined " + className); + assert(e.classList.contains(className), "classname isn't " + className); +} + +function toggle(aEvent) +{ + // This relies on each line being a span that contains at least four spans: + // mrValue, mrPerc, mrSep, mrName, and then zero or more mrNotes. All + // whitespace must be within one of these spans for this function to find the + // right nodes. And the span containing the children of this line must + // immediately follow. Assertions check this. + + // |aEvent.target| will be one of the spans. Get the outer span. + let outerSpan = aEvent.target.parentNode; + assertClassListContains(outerSpan, "hasKids"); + + // Toggle the '++'/'--' separator. + let isExpansion; + let sepSpan = outerSpan.childNodes[2]; + assertClassListContains(sepSpan, "mrSep"); + if (sepSpan.textContent === kHideKidsSep) { + isExpansion = true; + sepSpan.textContent = kShowKidsSep; + } else if (sepSpan.textContent === kShowKidsSep) { + isExpansion = false; + sepSpan.textContent = kHideKidsSep; + } else { + assert(false, "bad sepSpan textContent"); + } + + // Toggle visibility of the span containing this node's children. + let subTreeSpan = outerSpan.nextSibling; + assertClassListContains(subTreeSpan, "kids"); + subTreeSpan.classList.toggle("hidden"); + + // Record/unrecord that this sub-tree was toggled. + let safeTreeId = outerSpan.id; + if (gShowSubtreesBySafeTreeId[safeTreeId] !== undefined) { + delete gShowSubtreesBySafeTreeId[safeTreeId]; + } else { + gShowSubtreesBySafeTreeId[safeTreeId] = isExpansion; + } +} + +function expandPathToThisElement(aElement) +{ + if (aElement.classList.contains("kids")) { + // Unhide the kids. + aElement.classList.remove("hidden"); + expandPathToThisElement(aElement.previousSibling); // hasKids + + } else if (aElement.classList.contains("hasKids")) { + // Change the separator to '--'. + let sepSpan = aElement.childNodes[2]; + assertClassListContains(sepSpan, "mrSep"); + sepSpan.textContent = kShowKidsSep; + expandPathToThisElement(aElement.parentNode); // kids or pre.entries + + } else { + assertClassListContains(aElement, "entries"); + } +} + +/** + * Appends the elements for the tree, including its heading. + * + * @param aP + * The parent DOM node. + * @param aRoot + * The tree root. + * @param aProcess + * The process the tree corresponds to. + * @param aPadText + * A string to pad the start of each entry. + */ +function appendTreeElements(aP, aRoot, aProcess, aPadText) +{ + /** + * Appends the elements for a particular tree, without a heading. + * + * @param aP + * The parent DOM node. + * @param aProcess + * The process the tree corresponds to. + * @param aUnsafeNames + * An array of the names forming the path to aT. + * @param aRoot + * The root of the tree this sub-tree belongs to. + * @param aT + * The tree. + * @param aTreelineText1 + * The first part of the treeline for this entry and this entry's + * children. + * @param aTreelineText2a + * The second part of the treeline for this entry. + * @param aTreelineText2b + * The second part of the treeline for this entry's children. + * @param aParentStringLength + * The length of the formatted byte count of the top node in the tree. + */ + function appendTreeElements2(aP, aProcess, aUnsafeNames, aRoot, aT, + aTreelineText1, aTreelineText2a, + aTreelineText2b, aParentStringLength) + { + function appendN(aS, aC, aN) + { + for (let i = 0; i < aN; i++) { + aS += aC; + } + return aS; + } + + // The tree line. Indent more if this entry is narrower than its parent. + let valueText = aT.toString(); + let extraTreelineLength = + Math.max(aParentStringLength - valueText.length, 0); + if (extraTreelineLength > 0) { + aTreelineText2a = + appendN(aTreelineText2a, kHorizontal, extraTreelineLength); + aTreelineText2b = + appendN(aTreelineText2b, " ", extraTreelineLength); + } + let treelineText = aTreelineText1 + aTreelineText2a; + appendElementWithText(aP, "span", "treeline", treelineText); + + // Detect and record invalid values. But not if gIsDiff is true, because + // we expect negative values in that case. + assertInput(aRoot._units === aT._units, + "units within a tree are inconsistent"); + let tIsInvalid = false; + if (!gIsDiff && !(0 <= aT._amount && aT._amount <= aRoot._amount)) { + tIsInvalid = true; + let unsafePath = aUnsafeNames.join("/"); + gUnsafePathsWithInvalidValuesForThisProcess.push(unsafePath); + reportAssertionFailure("Invalid value (" + aT._amount + " / " + + aRoot._amount + ") for " + + flipBackslashes(unsafePath)); + } + + // For non-leaf nodes, the entire sub-tree is put within a span so it can + // be collapsed if the node is clicked on. + let d; + let sep; + let showSubtrees; + if (aT._kids) { + // Determine if we should show the sub-tree below this entry; this + // involves reinstating any previous toggling of the sub-tree. + let unsafePath = aUnsafeNames.join("/"); + let safeTreeId = aProcess + ":" + flipBackslashes(unsafePath); + showSubtrees = !aT._hideKids; + if (gShowSubtreesBySafeTreeId[safeTreeId] !== undefined) { + showSubtrees = gShowSubtreesBySafeTreeId[safeTreeId]; + } + d = appendElement(aP, "span", "hasKids"); + d.id = safeTreeId; + d.onclick = toggle; + sep = showSubtrees ? kShowKidsSep : kHideKidsSep; + } else { + assert(!aT._hideKids, "leaf node with _hideKids set") + sep = kNoKidsSep; + d = aP; + } + + // The value. + appendElementWithText(d, "span", "mrValue" + (tIsInvalid ? " invalid" : ""), + valueText); + + // The percentage (omitted for single entries). + let percText; + if (!aT._isDegenerate) { + // Treat 0 / 0 as 100%. + let num = aRoot._amount === 0 ? 100 : (100 * aT._amount / aRoot._amount); + let numText = num.toFixed(2); + percText = numText === "100.00" + ? " (100.0%)" + : (0 <= num && num < 10 ? " (0" : " (") + numText + "%)"; + appendElementWithText(d, "span", "mrPerc", percText); + } + + // The separator. + appendElementWithText(d, "span", "mrSep", sep); + + // The entry's name. + appendMrNameSpan(d, aT._description, aT._unsafeName, + tIsInvalid, aT._nMerged, aT._presence); + + // In non-verbose mode, invalid nodes can be hidden in collapsed sub-trees. + // But it's good to always see them, so force this. + if (!gVerbose.checked && tIsInvalid) { + expandPathToThisElement(d); + } + + // Recurse over children. + if (aT._kids) { + // The 'kids' class is just used for sanity checking in toggle(). + d = appendElement(aP, "span", showSubtrees ? "kids" : "kids hidden"); + + let kidTreelineText1 = aTreelineText1 + aTreelineText2b; + for (let i = 0; i < aT._kids.length; i++) { + let kidTreelineText2a, kidTreelineText2b; + if (i < aT._kids.length - 1) { + kidTreelineText2a = kVerticalAndRight_Right_Right; + kidTreelineText2b = kVertical_Space_Space; + } else { + kidTreelineText2a = kUpAndRight_Right_Right; + kidTreelineText2b = " "; + } + aUnsafeNames.push(aT._kids[i]._unsafeName); + appendTreeElements2(d, aProcess, aUnsafeNames, aRoot, aT._kids[i], + kidTreelineText1, kidTreelineText2a, + kidTreelineText2b, valueText.length); + aUnsafeNames.pop(); + } + } + } + + let rootStringLength = aRoot.toString().length; + appendTreeElements2(aP, aProcess, [aRoot._unsafeName], aRoot, aRoot, + aPadText, "", "", rootStringLength); +} + +// --------------------------------------------------------------------------- + +function appendSectionHeader(aP, aText) +{ + appendElementWithText(aP, "h2", "", aText + "\n"); + return appendElement(aP, "pre", "entries"); +} + +// --------------------------------------------------------------------------- + +function saveReportsToFile() +{ + let fp = Cc["@mozilla.org/filepicker;1"].createInstance(Ci.nsIFilePicker); + fp.appendFilter("Zipped JSON files", "*.json.gz"); + fp.appendFilters(Ci.nsIFilePicker.filterAll); + fp.filterIndex = 0; + fp.addToRecentDocs = true; + fp.defaultString = "memory-report.json.gz"; + + let fpFinish = function(file) { + let dumper = Cc["@mozilla.org/memory-info-dumper;1"] + .getService(Ci.nsIMemoryInfoDumper); + let finishDumping = () => { + updateMainAndFooter("Saved memory reports to " + file.path, HIDE_FOOTER); + } + dumper.dumpMemoryReportsToNamedFile(file.path, finishDumping, null, + gAnonymize.checked); + } + + let fpCallback = function(aResult) { + if (aResult == Ci.nsIFilePicker.returnOK || + aResult == Ci.nsIFilePicker.returnReplace) { + fpFinish(fp.file); + } + }; + + try { + fp.init(window, "Save Memory Reports", Ci.nsIFilePicker.modeSave); + } catch (ex) { + // This will fail on Android, since there is no Save as file picker there. + // Just save to the default downloads dir if it does. + Downloads.getSystemDownloadsDirectory().then(function(dirPath) { + let file = FileUtils.File(dirPath); + file.append(fp.defaultString); + fpFinish(file); + }); + + return; + } + fp.open(fpCallback); +} |