/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=8 sts=2 et sw=2 tw=80: */ /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ #include "amIAddonManager.h" #include "nsWindowMemoryReporter.h" #include "nsWindowSizes.h" #include "nsGlobalWindow.h" #include "nsIDocument.h" #include "nsIDOMWindowCollection.h" #include "mozilla/ClearOnShutdown.h" #include "mozilla/Preferences.h" #include "mozilla/Services.h" #include "mozilla/StaticPtr.h" #include "nsNetCID.h" #include "nsPrintfCString.h" #include "XPCJSMemoryReporter.h" #include "js/MemoryMetrics.h" #include "nsQueryObject.h" #include "nsServiceManagerUtils.h" using namespace mozilla; StaticRefPtr sWindowReporter; /** * Don't trigger a ghost window check when a DOM window is detached if we've * run it this recently. */ const int32_t kTimeBetweenChecks = 45; /* seconds */ nsWindowMemoryReporter::nsWindowMemoryReporter() : mLastCheckForGhostWindows(TimeStamp::NowLoRes()), mCycleCollectorIsRunning(false), mCheckTimerWaitingForCCEnd(false), mGhostWindowCount(0) { } nsWindowMemoryReporter::~nsWindowMemoryReporter() { KillCheckTimer(); } NS_IMPL_ISUPPORTS(nsWindowMemoryReporter, nsIMemoryReporter, nsIObserver, nsISupportsWeakReference) static nsresult AddNonJSSizeOfWindowAndItsDescendents(nsGlobalWindowOuter* aWindow, nsTabSizes* aSizes) { // Measure the window. SizeOfState state(moz_malloc_size_of); nsWindowSizes windowSizes(state); aWindow->AddSizeOfIncludingThis(windowSizes); // Measure the inner window, if there is one. nsGlobalWindowInner* inner = aWindow->GetCurrentInnerWindowInternal(); if (inner) { inner->AddSizeOfIncludingThis(windowSizes); } windowSizes.addToTabSizes(aSizes); nsCOMPtr frames = aWindow->GetFrames(); uint32_t length; nsresult rv = frames->GetLength(&length); NS_ENSURE_SUCCESS(rv, rv); // Measure this window's descendents. for (uint32_t i = 0; i < length; i++) { nsCOMPtr child; rv = frames->Item(i, getter_AddRefs(child)); NS_ENSURE_SUCCESS(rv, rv); NS_ENSURE_STATE(child); nsGlobalWindowOuter* childWin = nsGlobalWindowOuter::Cast(child); rv = AddNonJSSizeOfWindowAndItsDescendents(childWin, aSizes); NS_ENSURE_SUCCESS(rv, rv); } return NS_OK; } static nsresult NonJSSizeOfTab(nsPIDOMWindowOuter* aWindow, size_t* aDomSize, size_t* aStyleSize, size_t* aOtherSize) { nsGlobalWindowOuter* window = nsGlobalWindowOuter::Cast(aWindow); nsTabSizes sizes; nsresult rv = AddNonJSSizeOfWindowAndItsDescendents(window, &sizes); NS_ENSURE_SUCCESS(rv, rv); *aDomSize = sizes.mDom; *aStyleSize = sizes.mStyle; *aOtherSize = sizes.mOther; return NS_OK; } /* static */ void nsWindowMemoryReporter::Init() { MOZ_ASSERT(!sWindowReporter); sWindowReporter = new nsWindowMemoryReporter(); ClearOnShutdown(&sWindowReporter); RegisterStrongMemoryReporter(sWindowReporter); RegisterNonJSSizeOfTab(NonJSSizeOfTab); nsCOMPtr os = services::GetObserverService(); if (os) { os->AddObserver(sWindowReporter, "after-minimize-memory-usage", /* weakRef = */ true); os->AddObserver(sWindowReporter, "cycle-collector-begin", /* weakRef = */ true); os->AddObserver(sWindowReporter, "cycle-collector-end", /* weakRef = */ true); } RegisterGhostWindowsDistinguishedAmount(GhostWindowsDistinguishedAmount); } /* static */ nsWindowMemoryReporter* nsWindowMemoryReporter::Get() { return sWindowReporter; } static already_AddRefed GetWindowURI(nsGlobalWindowInner* aWindow) { NS_ENSURE_TRUE(aWindow, nullptr); nsCOMPtr doc = aWindow->GetExtantDoc(); nsCOMPtr uri; if (doc) { uri = doc->GetDocumentURI(); } if (!uri) { nsCOMPtr scriptObjPrincipal = do_QueryObject(aWindow); NS_ENSURE_TRUE(scriptObjPrincipal, nullptr); // GetPrincipal() will print a warning if the window does not have an outer // window, so check here for an outer window first. This code is // functionally correct if we leave out the GetOuterWindow() check, but we // end up printing a lot of warnings during debug mochitests. if (aWindow->GetOuterWindow()) { nsIPrincipal* principal = scriptObjPrincipal->GetPrincipal(); if (principal) { principal->GetURI(getter_AddRefs(uri)); } } } return uri.forget(); } // Forward to the inner window if we need to when getting the window's URI. static already_AddRefed GetWindowURI(nsGlobalWindowOuter* aWindow) { NS_ENSURE_TRUE(aWindow, nullptr); return GetWindowURI(aWindow->GetCurrentInnerWindowInternal()); } static void AppendWindowURI(nsGlobalWindowInner *aWindow, nsACString& aStr, bool aAnonymize) { nsCOMPtr uri = GetWindowURI(aWindow); if (uri) { if (aAnonymize && !aWindow->IsChromeWindow()) { aStr.AppendPrintf("", aWindow->WindowID()); } else { nsCString spec = uri->GetSpecOrDefault(); // A hack: replace forward slashes with '\\' so they aren't // treated as path separators. Users of the reporters // (such as about:memory) have to undo this change. spec.ReplaceChar('/', '\\'); aStr += spec; } } else { // If we're unable to find a URI, we're dealing with a chrome window with // no document in it (or somesuch), so we call this a "system window". aStr += NS_LITERAL_CSTRING("[system]"); } } MOZ_DEFINE_MALLOC_SIZE_OF(WindowsMallocSizeOf) // The key is the window ID. typedef nsDataHashtable WindowPaths; static void ReportAmount(const nsCString& aBasePath, const char* aPathTail, size_t aAmount, const nsCString& aDescription, uint32_t aKind, uint32_t aUnits, nsIHandleReportCallback* aHandleReport, nsISupports* aData) { if (aAmount == 0) { return; } nsAutoCString path(aBasePath); path += aPathTail; aHandleReport->Callback( EmptyCString(), path, aKind, aUnits, aAmount, aDescription, aData); } static void ReportSize(const nsCString& aBasePath, const char* aPathTail, size_t aAmount, const nsCString& aDescription, nsIHandleReportCallback* aHandleReport, nsISupports* aData) { ReportAmount(aBasePath, aPathTail, aAmount, aDescription, nsIMemoryReporter::KIND_HEAP, nsIMemoryReporter::UNITS_BYTES, aHandleReport, aData); } static void ReportCount(const nsCString& aBasePath, const char* aPathTail, size_t aAmount, const nsCString& aDescription, nsIHandleReportCallback* aHandleReport, nsISupports* aData) { ReportAmount(aBasePath, aPathTail, aAmount, aDescription, nsIMemoryReporter::KIND_OTHER, nsIMemoryReporter::UNITS_COUNT, aHandleReport, aData); } static void CollectWindowReports(nsGlobalWindowInner *aWindow, amIAddonManager *addonManager, nsWindowSizes *aWindowTotalSizes, nsTHashtable *aGhostWindowIDs, WindowPaths *aWindowPaths, WindowPaths *aTopWindowPaths, nsIHandleReportCallback *aHandleReport, nsISupports *aData, bool aAnonymize) { nsAutoCString windowPath("explicit/"); // Avoid calling aWindow->GetTop() if there's no outer window. It will work // just fine, but will spew a lot of warnings. nsGlobalWindowOuter *top = nullptr; nsCOMPtr location; if (aWindow->GetOuterWindow()) { // Our window should have a null top iff it has a null docshell. MOZ_ASSERT(!!aWindow->GetTopInternal() == !!aWindow->GetDocShell()); top = aWindow->GetTopInternal(); if (top) { location = GetWindowURI(top); } } if (!location) { location = GetWindowURI(aWindow); } if (addonManager && location) { bool ok; nsAutoCString id; if (NS_SUCCEEDED(addonManager->MapURIToAddonID(location, id, &ok)) && ok) { // Add-on names are not privacy-sensitive, so we can use them with // impunity. windowPath += NS_LITERAL_CSTRING("add-ons/") + id + NS_LITERAL_CSTRING("/"); } } windowPath += NS_LITERAL_CSTRING("window-objects/"); if (top) { windowPath += NS_LITERAL_CSTRING("top("); AppendWindowURI(top->GetCurrentInnerWindowInternal(), windowPath, aAnonymize); windowPath.AppendPrintf(", id=%" PRIu64 ")", top->WindowID()); aTopWindowPaths->Put(aWindow->WindowID(), windowPath); windowPath += aWindow->IsFrozen() ? NS_LITERAL_CSTRING("/cached/") : NS_LITERAL_CSTRING("/active/"); } else { if (aGhostWindowIDs->Contains(aWindow->WindowID())) { windowPath += NS_LITERAL_CSTRING("top(none)/ghost/"); } else { windowPath += NS_LITERAL_CSTRING("top(none)/detached/"); } } windowPath += NS_LITERAL_CSTRING("window("); AppendWindowURI(aWindow, windowPath, aAnonymize); windowPath += NS_LITERAL_CSTRING(")"); // Use |windowPath|, but replace "explicit/" with "event-counts/". nsCString censusWindowPath(windowPath); censusWindowPath.ReplaceLiteral(0, strlen("explicit"), "event-counts"); // Remember the path for later. aWindowPaths->Put(aWindow->WindowID(), windowPath); // Report the size from windowSizes and add to the appropriate total in // aWindowTotalSizes. #define REPORT_SIZE(_pathTail, _field, _desc) \ ReportSize(windowPath, _pathTail, windowSizes._field, \ NS_LITERAL_CSTRING(_desc), aHandleReport, aData); \ aWindowTotalSizes->_field += windowSizes._field; // Report the size, which is a sum of other sizes, and so doesn't require // updating aWindowTotalSizes. #define REPORT_SUM_SIZE(_pathTail, _amount, _desc) \ ReportSize(windowPath, _pathTail, _amount, NS_LITERAL_CSTRING(_desc), \ aHandleReport, aData); // Like REPORT_SIZE, but for a count. #define REPORT_COUNT(_pathTail, _field, _desc) \ ReportCount(censusWindowPath, _pathTail, windowSizes._field, \ NS_LITERAL_CSTRING(_desc), aHandleReport, aData); \ aWindowTotalSizes->_field += windowSizes._field; // This SizeOfState contains the SeenPtrs used for all memory reporting of // this window. SizeOfState state(WindowsMallocSizeOf); nsWindowSizes windowSizes(state); aWindow->AddSizeOfIncludingThis(windowSizes); REPORT_SIZE("/dom/element-nodes", mDOMElementNodesSize, "Memory used by the element nodes in a window's DOM."); REPORT_SIZE("/dom/text-nodes", mDOMTextNodesSize, "Memory used by the text nodes in a window's DOM."); REPORT_SIZE("/dom/cdata-nodes", mDOMCDATANodesSize, "Memory used by the CDATA nodes in a window's DOM."); REPORT_SIZE("/dom/comment-nodes", mDOMCommentNodesSize, "Memory used by the comment nodes in a window's DOM."); REPORT_SIZE("/dom/event-targets", mDOMEventTargetsSize, "Memory used by the event targets table in a window's DOM, and " "the objects it points to, which include XHRs."); REPORT_SIZE("/dom/performance/user-entries", mDOMPerformanceUserEntries, "Memory used for performance user entries."); REPORT_SIZE("/dom/performance/resource-entries", mDOMPerformanceResourceEntries, "Memory used for performance resource entries."); REPORT_SIZE("/dom/other", mDOMOtherSize, "Memory used by a window's DOM that isn't measured by the " "other 'dom/' numbers."); REPORT_SIZE("/layout/style-sheets", mLayoutStyleSheetsSize, "Memory used by style sheets within a window."); REPORT_SIZE("/layout/pres-shell", mLayoutPresShellSize, "Memory used by layout's PresShell, along with any structures " "allocated in its arena and not measured elsewhere, " "within a window."); REPORT_SIZE("/layout/gecko-style-sets", mLayoutGeckoStyleSets, "Memory used by Gecko style sets within a window."); REPORT_SIZE("/layout/servo-style-sets/stylist/rule-tree", mLayoutServoStyleSetsStylistRuleTree, "Memory used by rule trees within Servo style sets within a " "window."); REPORT_SIZE("/layout/servo-style-sets/stylist/element-and-pseudos-maps", mLayoutServoStyleSetsStylistElementAndPseudosMaps, "Memory used by element and pseudos maps within Servo style " "sets within a window."); REPORT_SIZE("/layout/servo-style-sets/stylist/invalidation-map", mLayoutServoStyleSetsStylistInvalidationMap, "Memory used by invalidation maps within Servo style sets " "within a window."); REPORT_SIZE("/layout/servo-style-sets/stylist/revalidation-selectors", mLayoutServoStyleSetsStylistRevalidationSelectors, "Memory used by selectors for cache revalidation within Servo " "style sets within a window."); REPORT_SIZE("/layout/servo-style-sets/stylist/other", mLayoutServoStyleSetsStylistOther, "Memory used by other Stylist data within Servo style sets " "within a window."); REPORT_SIZE("/layout/servo-style-sets/other", mLayoutServoStyleSetsOther, "Memory used by other parts of Servo style sets within a " "window."); REPORT_SIZE("/layout/servo-element-data-objects", mLayoutServoElementDataObjects, "Memory used for Servo ElementData objects, but not the things" "hanging off them."); REPORT_SIZE("/layout/text-runs", mLayoutTextRunsSize, "Memory used for text-runs (glyph layout) in the PresShell's " "frame tree, within a window."); REPORT_SIZE("/layout/pres-contexts", mLayoutPresContextSize, "Memory used for the PresContext in the PresShell's frame " "within a window."); REPORT_SIZE("/layout/frame-properties", mLayoutFramePropertiesSize, "Memory used for frame properties attached to frames " "within a window."); REPORT_SIZE("/layout/computed-values/dom", mLayoutComputedValuesDom, "Memory used by ComputedValues objects accessible from DOM " "elements."); REPORT_SIZE("/layout/computed-values/non-dom", mLayoutComputedValuesNonDom, "Memory used by ComputedValues objects not accessible from DOM " "elements."); REPORT_SIZE("/layout/computed-values/visited", mLayoutComputedValuesVisited, "Memory used by ComputedValues objects used for visited styles."); REPORT_SIZE("/property-tables", mPropertyTablesSize, "Memory used for the property tables within a window."); REPORT_COUNT("/dom/event-targets", mDOMEventTargetsCount, "Number of non-node event targets in the event targets table " "in a window's DOM, such as XHRs."); REPORT_COUNT("/dom/event-listeners", mDOMEventListenersCount, "Number of event listeners in a window, including event " "listeners on nodes and other event targets."); REPORT_SIZE("/layout/line-boxes", mArenaSizes.mLineBoxes, "Memory used by line boxes within a window."); REPORT_SIZE("/layout/rule-nodes", mArenaSizes.mRuleNodes, "Memory used by CSS rule nodes within a window."); REPORT_SIZE("/layout/style-contexts", mArenaSizes.mStyleContexts, "Memory used by style contexts within a window."); // There are many different kinds of style structs, but it is likely that // only a few matter. Implement a cutoff so we don't bloat about:memory with // many uninteresting entries. const size_t STYLE_SUNDRIES_THRESHOLD = js::MemoryReportingSundriesThreshold(); // This is the Gecko style structs, which are in the nsPresArena. size_t geckoStyleSundriesSize = 0; #define STYLE_STRUCT(name_, cb_) \ { \ size_t size = \ windowSizes.mArenaSizes.mGeckoStyleSizes.NS_STYLE_SIZES_FIELD(name_); \ if (size < STYLE_SUNDRIES_THRESHOLD) { \ geckoStyleSundriesSize += size; \ } else { \ REPORT_SUM_SIZE( \ "/layout/gecko-style-structs/" # name_, size, \ "Memory used by the " #name_ " Gecko style structs within a window."); \ } \ aWindowTotalSizes->mArenaSizes.mGeckoStyleSizes.NS_STYLE_SIZES_FIELD(name_) += \ size; \ } #define STYLE_STRUCT_LIST_IGNORE_VARIABLES #include "nsStyleStructList.h" #undef STYLE_STRUCT #undef STYLE_STRUCT_LIST_IGNORE_VARIABLES if (geckoStyleSundriesSize > 0) { REPORT_SUM_SIZE( "/layout/gecko-style-structs/sundries", geckoStyleSundriesSize, "The sum of all memory used by Gecko style structs which were too small " "to be shown individually."); } // There are many different kinds of frames, but it is very likely // that only a few matter. Implement a cutoff so we don't bloat // about:memory with many uninteresting entries. const size_t FRAME_SUNDRIES_THRESHOLD = js::MemoryReportingSundriesThreshold(); size_t frameSundriesSize = 0; #define FRAME_ID(classname, ...) \ { \ size_t size = windowSizes.mArenaSizes.NS_ARENA_SIZES_FIELD(classname); \ if (size < FRAME_SUNDRIES_THRESHOLD) { \ frameSundriesSize += size; \ } else { \ REPORT_SUM_SIZE( \ "/layout/frames/" # classname, size, \ "Memory used by frames of type " #classname " within a window."); \ } \ aWindowTotalSizes->mArenaSizes.NS_ARENA_SIZES_FIELD(classname) += size; \ } #define ABSTRACT_FRAME_ID(...) #include "nsFrameIdList.h" #undef FRAME_ID #undef ABSTRACT_FRAME_ID if (frameSundriesSize > 0) { REPORT_SUM_SIZE( "/layout/frames/sundries", frameSundriesSize, "The sum of all memory used by frames which were too small to be shown " "individually."); } // This is the Servo style structs. size_t servoStyleSundriesSize = 0; #define STYLE_STRUCT(name_, cb_) \ { \ size_t size = windowSizes.mServoStyleSizes.NS_STYLE_SIZES_FIELD(name_); \ if (size < STYLE_SUNDRIES_THRESHOLD) { \ servoStyleSundriesSize += size; \ } else { \ REPORT_SUM_SIZE( \ "/layout/servo-style-structs/" # name_, size, \ "Memory used by the " #name_ " Servo style structs within a window."); \ } \ aWindowTotalSizes->mServoStyleSizes.NS_STYLE_SIZES_FIELD(name_) += size; \ } #define STYLE_STRUCT_LIST_IGNORE_VARIABLES #include "nsStyleStructList.h" #undef STYLE_STRUCT #undef STYLE_STRUCT_LIST_IGNORE_VARIABLES if (servoStyleSundriesSize > 0) { REPORT_SUM_SIZE( "/layout/servo-style-structs/sundries", servoStyleSundriesSize, "The sum of all memory used by Servo style structs which were too " "small to be shown individually."); } #undef REPORT_SIZE #undef REPORT_SUM_SIZE #undef REPORT_COUNT } typedef nsTArray< RefPtr > WindowArray; NS_IMETHODIMP nsWindowMemoryReporter::CollectReports(nsIHandleReportCallback* aHandleReport, nsISupports* aData, bool aAnonymize) { nsGlobalWindowInner::InnerWindowByIdTable* windowsById = nsGlobalWindowInner::GetWindowsTable(); NS_ENSURE_TRUE(windowsById, NS_OK); // Hold on to every window in memory so that window objects can't be // destroyed while we're calling the memory reporter callback. WindowArray windows; for (auto iter = windowsById->Iter(); !iter.Done(); iter.Next()) { windows.AppendElement(iter.Data()); } // Get the IDs of all the "ghost" windows, and call aHandleReport->Callback() // for each one. nsTHashtable ghostWindows; CheckForGhostWindows(&ghostWindows); for (auto iter = ghostWindows.ConstIter(); !iter.Done(); iter.Next()) { nsGlobalWindowInner::InnerWindowByIdTable* windowsById = nsGlobalWindowInner::GetWindowsTable(); if (!windowsById) { NS_WARNING("Couldn't get window-by-id hashtable?"); continue; } nsGlobalWindowInner* window = windowsById->Get(iter.Get()->GetKey()); if (!window) { NS_WARNING("Could not look up window?"); continue; } nsAutoCString path; path.AppendLiteral("ghost-windows/"); AppendWindowURI(window, path, aAnonymize); aHandleReport->Callback( /* process = */ EmptyCString(), path, nsIMemoryReporter::KIND_OTHER, nsIMemoryReporter::UNITS_COUNT, /* amount = */ 1, /* description = */ NS_LITERAL_CSTRING("A ghost window."), aData); } MOZ_COLLECT_REPORT( "ghost-windows", KIND_OTHER, UNITS_COUNT, ghostWindows.Count(), "The number of ghost windows present (the number of nodes underneath " "explicit/window-objects/top(none)/ghost, modulo race conditions). A ghost " "window is not shown in any tab, is not in a tab group with any " "non-detached windows, and has met these criteria for at least " "memory.ghost_window_timeout_seconds, or has survived a round of " "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."); WindowPaths windowPaths; WindowPaths topWindowPaths; // Collect window memory usage. SizeOfState fakeState(nullptr); // this won't be used nsWindowSizes windowTotalSizes(fakeState); nsCOMPtr addonManager; if (XRE_IsParentProcess()) { // Only try to access the service from the main process. addonManager = do_GetService("@mozilla.org/addons/integration;1"); } for (uint32_t i = 0; i < windows.Length(); i++) { CollectWindowReports(windows[i], addonManager, &windowTotalSizes, &ghostWindows, &windowPaths, &topWindowPaths, aHandleReport, aData, aAnonymize); } // Report JS memory usage. We do this from here because the JS memory // reporter needs to be passed |windowPaths|. xpc::JSReporter::CollectReports(&windowPaths, &topWindowPaths, aHandleReport, aData, aAnonymize); #define REPORT(_path, _amount, _desc) \ aHandleReport->Callback(EmptyCString(), NS_LITERAL_CSTRING(_path), \ KIND_OTHER, UNITS_BYTES, _amount, \ NS_LITERAL_CSTRING(_desc), aData); REPORT("window-objects/dom/element-nodes", windowTotalSizes.mDOMElementNodesSize, "This is the sum of all windows' 'dom/element-nodes' numbers."); REPORT("window-objects/dom/text-nodes", windowTotalSizes.mDOMTextNodesSize, "This is the sum of all windows' 'dom/text-nodes' numbers."); REPORT("window-objects/dom/cdata-nodes", windowTotalSizes.mDOMCDATANodesSize, "This is the sum of all windows' 'dom/cdata-nodes' numbers."); REPORT("window-objects/dom/comment-nodes", windowTotalSizes.mDOMCommentNodesSize, "This is the sum of all windows' 'dom/comment-nodes' numbers."); REPORT("window-objects/dom/event-targets", windowTotalSizes.mDOMEventTargetsSize, "This is the sum of all windows' 'dom/event-targets' numbers."); REPORT("window-objects/dom/performance", windowTotalSizes.mDOMPerformanceUserEntries + windowTotalSizes.mDOMPerformanceResourceEntries, "This is the sum of all windows' 'dom/performance/' numbers."); REPORT("window-objects/dom/other", windowTotalSizes.mDOMOtherSize, "This is the sum of all windows' 'dom/other' numbers."); REPORT("window-objects/layout/style-sheets", windowTotalSizes.mLayoutStyleSheetsSize, "This is the sum of all windows' 'layout/style-sheets' numbers."); REPORT("window-objects/layout/pres-shell", windowTotalSizes.mLayoutPresShellSize, "This is the sum of all windows' 'layout/arenas' numbers."); REPORT("window-objects/layout/gecko-style-sets", windowTotalSizes.mLayoutGeckoStyleSets, "This is the sum of all windows' 'layout/gecko-style-sets' numbers."); REPORT("window-objects/layout/servo-style-sets", windowTotalSizes.mLayoutServoStyleSetsStylistRuleTree + windowTotalSizes.mLayoutServoStyleSetsStylistElementAndPseudosMaps + windowTotalSizes.mLayoutServoStyleSetsStylistInvalidationMap + windowTotalSizes.mLayoutServoStyleSetsStylistRevalidationSelectors + windowTotalSizes.mLayoutServoStyleSetsStylistOther + windowTotalSizes.mLayoutServoStyleSetsOther, "This is the sum of all windows' 'layout/servo-style-sets/' numbers."); REPORT("window-objects/layout/servo-element-data-objects", windowTotalSizes.mLayoutServoElementDataObjects, "This is the sum of all windows' 'layout/servo-element-data-objects' " "numbers."); REPORT("window-objects/layout/text-runs", windowTotalSizes.mLayoutTextRunsSize, "This is the sum of all windows' 'layout/text-runs' numbers."); REPORT("window-objects/layout/pres-contexts", windowTotalSizes.mLayoutPresContextSize, "This is the sum of all windows' 'layout/pres-contexts' numbers."); REPORT("window-objects/layout/frame-properties", windowTotalSizes.mLayoutFramePropertiesSize, "This is the sum of all windows' 'layout/frame-properties' numbers."); REPORT("window-objects/layout/computed-values", windowTotalSizes.mLayoutComputedValuesDom + windowTotalSizes.mLayoutComputedValuesNonDom + windowTotalSizes.mLayoutComputedValuesVisited, "This is the sum of all windows' 'layout/computed-values/' numbers."); REPORT("window-objects/property-tables", windowTotalSizes.mPropertyTablesSize, "This is the sum of all windows' 'property-tables' numbers."); REPORT("window-objects/layout/line-boxes", windowTotalSizes.mArenaSizes.mLineBoxes, "This is the sum of all windows' 'layout/line-boxes' numbers."); REPORT("window-objects/layout/rule-nodes", windowTotalSizes.mArenaSizes.mRuleNodes, "This is the sum of all windows' 'layout/rule-nodes' numbers."); REPORT("window-objects/layout/style-contexts", windowTotalSizes.mArenaSizes.mStyleContexts, "This is the sum of all windows' 'layout/style-contexts' numbers."); size_t geckoStyleTotal = 0; #define STYLE_STRUCT(name_, cb_) \ geckoStyleTotal += \ windowTotalSizes.mArenaSizes.mGeckoStyleSizes.NS_STYLE_SIZES_FIELD(name_); #define STYLE_STRUCT_LIST_IGNORE_VARIABLES #include "nsStyleStructList.h" #undef STYLE_STRUCT #undef STYLE_STRUCT_LIST_IGNORE_VARIABLES REPORT("window-objects/layout/gecko-style-structs", geckoStyleTotal, "Memory used for style structs within windows. This is the sum of " "all windows' 'layout/gecko-style-structs/' numbers."); size_t frameTotal = 0; #define FRAME_ID(classname, ...) \ frameTotal += windowTotalSizes.mArenaSizes.NS_ARENA_SIZES_FIELD(classname); #define ABSTRACT_FRAME_ID(...) #include "nsFrameIdList.h" #undef FRAME_ID #undef ABSTRACT_FRAME_ID REPORT("window-objects/layout/frames", frameTotal, "Memory used for layout frames within windows. " "This is the sum of all windows' 'layout/frames/' numbers."); size_t servoStyleTotal = 0; #define STYLE_STRUCT(name_, cb_) \ servoStyleTotal += \ windowTotalSizes.mServoStyleSizes.NS_STYLE_SIZES_FIELD(name_); #define STYLE_STRUCT_LIST_IGNORE_VARIABLES #include "nsStyleStructList.h" #undef STYLE_STRUCT #undef STYLE_STRUCT_LIST_IGNORE_VARIABLES REPORT("window-objects/layout/servo-style-structs", servoStyleTotal, "Memory used for style structs within windows. This is the sum of " "all windows' 'layout/servo-style-structs/' numbers."); #undef REPORT return NS_OK; } uint32_t nsWindowMemoryReporter::GetGhostTimeout() { return Preferences::GetUint("memory.ghost_window_timeout_seconds", 60); } NS_IMETHODIMP nsWindowMemoryReporter::Observe(nsISupports *aSubject, const char *aTopic, const char16_t *aData) { if (!strcmp(aTopic, "after-minimize-memory-usage")) { ObserveAfterMinimizeMemoryUsage(); } else if (!strcmp(aTopic, "cycle-collector-begin")) { if (mCheckTimer) { mCheckTimerWaitingForCCEnd = true; KillCheckTimer(); } mCycleCollectorIsRunning = true; } else if (!strcmp(aTopic, "cycle-collector-end")) { mCycleCollectorIsRunning = false; if (mCheckTimerWaitingForCCEnd) { mCheckTimerWaitingForCCEnd = false; AsyncCheckForGhostWindows(); } } else { MOZ_ASSERT(false); } return NS_OK; } void nsWindowMemoryReporter::ObserveDOMWindowDetached(nsGlobalWindowInner* aWindow) { nsWeakPtr weakWindow = do_GetWeakReference(static_cast(aWindow)); if (!weakWindow) { NS_WARNING("Couldn't take weak reference to a window?"); return; } mDetachedWindows.Put(weakWindow, TimeStamp()); AsyncCheckForGhostWindows(); } // static void nsWindowMemoryReporter::CheckTimerFired(nsITimer* aTimer, void* aData) { if (sWindowReporter) { MOZ_ASSERT(!sWindowReporter->mCycleCollectorIsRunning); sWindowReporter->CheckForGhostWindows(); } } void nsWindowMemoryReporter::AsyncCheckForGhostWindows() { if (mCheckTimer) { return; } if (mCycleCollectorIsRunning) { mCheckTimerWaitingForCCEnd = true; return; } // If more than kTimeBetweenChecks seconds have elapsed since the last check, // timerDelay is 0. Otherwise, it is kTimeBetweenChecks, reduced by the time // since the last check. Reducing the delay by the time since the last check // prevents the timer from being completely starved if it is repeatedly killed // and restarted. int32_t timeSinceLastCheck = (TimeStamp::NowLoRes() - mLastCheckForGhostWindows).ToSeconds(); int32_t timerDelay = (kTimeBetweenChecks - std::min(timeSinceLastCheck, kTimeBetweenChecks)) * PR_MSEC_PER_SEC; NS_NewTimerWithFuncCallback(getter_AddRefs(mCheckTimer), CheckTimerFired, nullptr, timerDelay, nsITimer::TYPE_ONE_SHOT, "nsWindowMemoryReporter::AsyncCheckForGhostWindows_timer"); } void nsWindowMemoryReporter::ObserveAfterMinimizeMemoryUsage() { // Someone claims they've done enough GC/CCs so that all eligible windows // have been free'd. So we deem that any windows which satisfy ghost // criteria (1) and (2) now satisfy criterion (3) as well. // // To effect this change, we'll backdate some of our timestamps. TimeStamp minTimeStamp = TimeStamp::Now() - TimeDuration::FromSeconds(GetGhostTimeout()); for (auto iter = mDetachedWindows.Iter(); !iter.Done(); iter.Next()) { TimeStamp& timeStamp = iter.Data(); if (!timeStamp.IsNull() && timeStamp > minTimeStamp) { timeStamp = minTimeStamp; } } } /** * Iterate over mDetachedWindows and update it to reflect the current state of * the world. In particular: * * - Remove weak refs to windows which no longer exist. * * - Remove references to windows which are no longer detached. * * - Reset the timestamp on detached windows which share a domain with a * non-detached window (they no longer meet ghost criterion (2)). * * - If a window now meets ghost criterion (2) but didn't before, set its * timestamp to now. * * Additionally, if aOutGhostIDs is not null, fill it with the window IDs of * all ghost windows we found. */ void nsWindowMemoryReporter::CheckForGhostWindows( nsTHashtable *aOutGhostIDs /* = nullptr */) { nsGlobalWindowInner::InnerWindowByIdTable *windowsById = nsGlobalWindowInner::GetWindowsTable(); if (!windowsById) { NS_WARNING("GetWindowsTable returned null"); return; } mLastCheckForGhostWindows = TimeStamp::NowLoRes(); KillCheckTimer(); nsTHashtable> nonDetachedTabGroups; // Populate nonDetachedTabGroups. for (auto iter = windowsById->Iter(); !iter.Done(); iter.Next()) { // Null outer window implies null top, but calling GetTop() when there's no // outer window causes us to spew debug warnings. nsGlobalWindowInner* window = iter.UserData(); if (!window->GetOuterWindow() || !window->GetTopInternal()) { // This window is detached, so we don't care about its tab group. continue; } nonDetachedTabGroups.PutEntry(window->TabGroup()); } // Update mDetachedWindows and write the ghost window IDs into aOutGhostIDs, // if it's not null. uint32_t ghostTimeout = GetGhostTimeout(); TimeStamp now = mLastCheckForGhostWindows; mGhostWindowCount = 0; for (auto iter = mDetachedWindows.Iter(); !iter.Done(); iter.Next()) { nsWeakPtr weakKey = do_QueryInterface(iter.Key()); nsCOMPtr iwindow = do_QueryReferent(weakKey); if (!iwindow) { // The window object has been destroyed. Stop tracking its weak ref in // our hashtable. iter.Remove(); continue; } nsPIDOMWindowInner* window = nsPIDOMWindowInner::From(iwindow); // Avoid calling GetTop() if we have no outer window. Nothing will break if // we do, but it will spew debug output, which can cause our test logs to // overflow. nsCOMPtr top; if (window->GetOuterWindow()) { top = window->GetOuterWindow()->GetTop(); } if (top) { // The window is no longer detached, so we no longer want to track it. iter.Remove(); continue; } TimeStamp& timeStamp = iter.Data(); if (nonDetachedTabGroups.GetEntry(window->TabGroup())) { // This window is in the same tab group as a non-detached // window, so reset its clock. timeStamp = TimeStamp(); } else { // This window is not in the same tab group as a non-detached // window, so it meets ghost criterion (2). if (timeStamp.IsNull()) { // This may become a ghost window later; start its clock. timeStamp = now; } else if ((now - timeStamp).ToSeconds() > ghostTimeout) { // This definitely is a ghost window, so add it to aOutGhostIDs, if // that is not null. mGhostWindowCount++; if (aOutGhostIDs && window) { aOutGhostIDs->PutEntry(window->WindowID()); } } } } } /* static */ int64_t nsWindowMemoryReporter::GhostWindowsDistinguishedAmount() { return sWindowReporter->mGhostWindowCount; } void nsWindowMemoryReporter::KillCheckTimer() { if (mCheckTimer) { mCheckTimer->Cancel(); mCheckTimer = nullptr; } } #ifdef DEBUG /* static */ void nsWindowMemoryReporter::UnlinkGhostWindows() { if (!sWindowReporter) { return; } nsGlobalWindowInner::InnerWindowByIdTable* windowsById = nsGlobalWindowInner::GetWindowsTable(); if (!windowsById) { return; } // Hold on to every window in memory so that window objects can't be // destroyed while we're calling the UnlinkGhostWindows callback. WindowArray windows; for (auto iter = windowsById->Iter(); !iter.Done(); iter.Next()) { windows.AppendElement(iter.Data()); } // Get the IDs of all the "ghost" windows, and unlink them all. nsTHashtable ghostWindows; sWindowReporter->CheckForGhostWindows(&ghostWindows); for (auto iter = ghostWindows.ConstIter(); !iter.Done(); iter.Next()) { nsGlobalWindowInner::InnerWindowByIdTable* windowsById = nsGlobalWindowInner::GetWindowsTable(); if (!windowsById) { continue; } RefPtr window = windowsById->Get(iter.Get()->GetKey()); if (window) { window->RiskyUnlink(); } } } #endif