Adding upstream version 86.0.1.upstream/86.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 875 insertions, 0 deletions

diff --git a/js/src/vm/MemoryMetrics.cpp b/js/src/vm/MemoryMetrics.cpp
new file mode 100644
index 0000000000..beb25bc711
--- /dev/null
+++ b/js/src/vm/MemoryMetrics.cpp
@@ -0,0 +1,875 @@
+/* -*- 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 "js/MemoryMetrics.h"
+
+#include "mozilla/MathAlgorithms.h"
+
+#include <algorithm>
+
+#include "gc/GC.h"
+#include "gc/Nursery.h"
+#include "gc/PublicIterators.h"
+#include "jit/BaselineJIT.h"
+#include "jit/Ion.h"
+#include "util/Text.h"
+#include "vm/ArrayObject.h"
+#include "vm/BigIntType.h"
+#include "vm/HelperThreadState.h"
+#include "vm/JSObject.h"
+#include "vm/JSScript.h"
+#include "vm/Realm.h"
+#include "vm/Runtime.h"
+#include "vm/Shape.h"
+#include "vm/StringType.h"
+#include "vm/SymbolType.h"
+#include "vm/WrapperObject.h"
+#include "wasm/WasmInstance.h"
+#include "wasm/WasmJS.h"
+#include "wasm/WasmModule.h"
+
+using mozilla::MallocSizeOf;
+using mozilla::PodCopy;
+
+using namespace js;
+
+using JS::ObjectPrivateVisitor;
+using JS::RealmStats;
+using JS::RuntimeStats;
+using JS::ZoneStats;
+
+namespace js {
+
+JS_FRIEND_API size_t MemoryReportingSundriesThreshold() { return 8 * 1024; }
+
+/* static */
+HashNumber InefficientNonFlatteningStringHashPolicy::hash(const Lookup& l) {
+  if (l->isLinear()) {
+    return HashStringChars(&l->asLinear());
+  }
+
+  // Use rope's non-copying hash function.
+  uint32_t hash = 0;
+  if (!l->asRope().hash(&hash)) {
+    MOZ_CRASH("oom");
+  }
+  return hash;
+}
+
+template <typename Char1, typename Char2>
+static bool EqualStringsPure(JSString* s1, JSString* s2) {
+  if (s1->length() != s2->length()) {
+    return false;
+  }
+
+  const Char1* c1;
+  UniquePtr<Char1[], JS::FreePolicy> ownedChars1;
+  JS::AutoCheckCannotGC nogc;
+  if (s1->isLinear()) {
+    c1 = s1->asLinear().chars<Char1>(nogc);
+  } else {
+    ownedChars1 =
+        s1->asRope().copyChars<Char1>(/* tcx */ nullptr, js::MallocArena);
+    if (!ownedChars1) {
+      MOZ_CRASH("oom");
+    }
+    c1 = ownedChars1.get();
+  }
+
+  const Char2* c2;
+  UniquePtr<Char2[], JS::FreePolicy> ownedChars2;
+  if (s2->isLinear()) {
+    c2 = s2->asLinear().chars<Char2>(nogc);
+  } else {
+    ownedChars2 =
+        s2->asRope().copyChars<Char2>(/* tcx */ nullptr, js::MallocArena);
+    if (!ownedChars2) {
+      MOZ_CRASH("oom");
+    }
+    c2 = ownedChars2.get();
+  }
+
+  return EqualChars(c1, c2, s1->length());
+}
+
+/* static */
+bool InefficientNonFlatteningStringHashPolicy::match(const JSString* const& k,
+                                                     const Lookup& l) {
+  // We can't use js::EqualStrings, because that flattens our strings.
+  JSString* s1 = const_cast<JSString*>(k);
+  if (k->hasLatin1Chars()) {
+    return l->hasLatin1Chars() ? EqualStringsPure<Latin1Char, Latin1Char>(s1, l)
+                               : EqualStringsPure<Latin1Char, char16_t>(s1, l);
+  }
+
+  return l->hasLatin1Chars() ? EqualStringsPure<char16_t, Latin1Char>(s1, l)
+                             : EqualStringsPure<char16_t, char16_t>(s1, l);
+}
+
+}  // namespace js
+
+namespace JS {
+
+template <typename CharT>
+static void StoreStringChars(char* buffer, size_t bufferSize, JSString* str) {
+  const CharT* chars;
+  UniquePtr<CharT[], JS::FreePolicy> ownedChars;
+  JS::AutoCheckCannotGC nogc;
+  if (str->isLinear()) {
+    chars = str->asLinear().chars<CharT>(nogc);
+  } else {
+    ownedChars =
+        str->asRope().copyChars<CharT>(/* tcx */ nullptr, js::MallocArena);
+    if (!ownedChars) {
+      MOZ_CRASH("oom");
+    }
+    chars = ownedChars.get();
+  }
+
+  // We might truncate |str| even if it's much shorter than 1024 chars, if
+  // |str| contains unicode chars.  Since this is just for a memory reporter,
+  // we don't care.
+  PutEscapedString(buffer, bufferSize, chars, str->length(), /* quote */ 0);
+}
+
+NotableStringInfo::NotableStringInfo(JSString* str, const StringInfo& info)
+    : StringInfo(info), length(str->length()) {
+  size_t bufferSize = std::min(str->length() + 1, size_t(MAX_SAVED_CHARS));
+  buffer.reset(js_pod_malloc<char>(bufferSize));
+  if (!buffer) {
+    MOZ_CRASH("oom");
+  }
+
+  if (str->hasLatin1Chars()) {
+    StoreStringChars<Latin1Char>(buffer.get(), bufferSize, str);
+  } else {
+    StoreStringChars<char16_t>(buffer.get(), bufferSize, str);
+  }
+}
+
+NotableClassInfo::NotableClassInfo(const char* className, const ClassInfo& info)
+    : ClassInfo(info) {
+  className_ = DuplicateString(className);
+  if (!className_) {
+    MOZ_CRASH("oom");
+  }
+}
+
+NotableScriptSourceInfo::NotableScriptSourceInfo(const char* filename,
+                                                 const ScriptSourceInfo& info)
+    : ScriptSourceInfo(info) {
+  filename_ = DuplicateString(filename);
+  if (!filename_) {
+    MOZ_CRASH("oom");
+  }
+}
+
+}  // namespace JS
+
+typedef HashSet<ScriptSource*, DefaultHasher<ScriptSource*>, SystemAllocPolicy>
+    SourceSet;
+
+struct StatsClosure {
+  RuntimeStats* rtStats;
+  ObjectPrivateVisitor* opv;
+  SourceSet seenSources;
+  wasm::Metadata::SeenSet wasmSeenMetadata;
+  wasm::Code::SeenSet wasmSeenCode;
+  wasm::Table::SeenSet wasmSeenTables;
+  bool anonymize;
+
+  StatsClosure(RuntimeStats* rt, ObjectPrivateVisitor* v, bool anon)
+      : rtStats(rt), opv(v), anonymize(anon) {}
+};
+
+static void DecommittedArenasChunkCallback(JSRuntime* rt, void* data,
+                                           gc::TenuredChunk* chunk,
+                                           const JS::AutoRequireNoGC& nogc) {
+  size_t n = 0;
+  for (uint32_t word : chunk->decommittedArenas.Storage()) {
+    n += mozilla::CountPopulation32(word);
+  }
+
+  *static_cast<size_t*>(data) += n * gc::ArenaSize;
+}
+
+static void StatsZoneCallback(JSRuntime* rt, void* data, Zone* zone,
+                              const JS::AutoRequireNoGC& nogc) {
+  // Append a new RealmStats to the vector.
+  RuntimeStats* rtStats = static_cast<StatsClosure*>(data)->rtStats;
+
+  // CollectRuntimeStats reserves enough space.
+  MOZ_ALWAYS_TRUE(rtStats->zoneStatsVector.growBy(1));
+  ZoneStats& zStats = rtStats->zoneStatsVector.back();
+  zStats.initStrings();
+  rtStats->initExtraZoneStats(zone, &zStats, nogc);
+  rtStats->currZoneStats = &zStats;
+
+  zone->addSizeOfIncludingThis(
+      rtStats->mallocSizeOf_, &zStats.code, &zStats.regexpZone, &zStats.jitZone,
+      &zStats.baselineStubsOptimized, &zStats.uniqueIdMap, &zStats.shapeTables,
+      &rtStats->runtime.atomsMarkBitmaps, &zStats.compartmentObjects,
+      &zStats.crossCompartmentWrappersTables, &zStats.compartmentsPrivateData,
+      &zStats.scriptCountsMap);
+}
+
+static void StatsRealmCallback(JSContext* cx, void* data, Realm* realm,
+                               const JS::AutoRequireNoGC& nogc) {
+  // Append a new RealmStats to the vector.
+  RuntimeStats* rtStats = static_cast<StatsClosure*>(data)->rtStats;
+
+  // CollectRuntimeStats reserves enough space.
+  MOZ_ALWAYS_TRUE(rtStats->realmStatsVector.growBy(1));
+  RealmStats& realmStats = rtStats->realmStatsVector.back();
+  realmStats.initClasses();
+  rtStats->initExtraRealmStats(realm, &realmStats, nogc);
+
+  realm->setRealmStats(&realmStats);
+
+  // Measure the realm object itself, and things hanging off it.
+  realm->addSizeOfIncludingThis(
+      rtStats->mallocSizeOf_, &realmStats.realmObject, &realmStats.realmTables,
+      &realmStats.innerViewsTable, &realmStats.objectMetadataTable,
+      &realmStats.savedStacksSet, &realmStats.varNamesSet,
+      &realmStats.nonSyntacticLexicalScopesTable, &realmStats.jitRealm);
+}
+
+static void StatsArenaCallback(JSRuntime* rt, void* data, gc::Arena* arena,
+                               JS::TraceKind traceKind, size_t thingSize,
+                               const JS::AutoRequireNoGC& nogc) {
+  RuntimeStats* rtStats = static_cast<StatsClosure*>(data)->rtStats;
+
+  // The admin space includes (a) the header fields and (b) the padding
+  // between the end of the header fields and the first GC thing.
+  size_t allocationSpace = gc::Arena::thingsSpan(arena->getAllocKind());
+  rtStats->currZoneStats->gcHeapArenaAdmin += gc::ArenaSize - allocationSpace;
+
+  // We don't call the callback on unused things.  So we compute the
+  // unused space like this:  arenaUnused = maxArenaUnused - arenaUsed.
+  // We do this by setting arenaUnused to maxArenaUnused here, and then
+  // subtracting thingSize for every used cell, in StatsCellCallback().
+  rtStats->currZoneStats->unusedGCThings.addToKind(traceKind, allocationSpace);
+}
+
+// FineGrained is used for normal memory reporting.  CoarseGrained is used by
+// AddSizeOfTab(), which aggregates all the measurements into a handful of
+// high-level numbers, which means that fine-grained reporting would be a waste
+// of effort.
+enum Granularity { FineGrained, CoarseGrained };
+
+static void AddClassInfo(Granularity granularity, RealmStats& realmStats,
+                         const char* className, JS::ClassInfo& info) {
+  if (granularity == FineGrained) {
+    if (!className) {
+      className = "<no class name>";
+    }
+    RealmStats::ClassesHashMap::AddPtr p =
+        realmStats.allClasses->lookupForAdd(className);
+    if (!p) {
+      bool ok = realmStats.allClasses->add(p, className, info);
+      // Ignore failure -- we just won't record the
+      // object/shape/base-shape as notable.
+      (void)ok;
+    } else {
+      p->value().add(info);
+    }
+  }
+}
+
+template <Granularity granularity>
+static void CollectScriptSourceStats(StatsClosure* closure, ScriptSource* ss) {
+  RuntimeStats* rtStats = closure->rtStats;
+
+  SourceSet::AddPtr entry = closure->seenSources.lookupForAdd(ss);
+  if (entry) {
+    return;
+  }
+
+  bool ok = closure->seenSources.add(entry, ss);
+  (void)ok;  // Not much to be done on failure.
+
+  JS::ScriptSourceInfo info;  // This zeroes all the sizes.
+  ss->addSizeOfIncludingThis(rtStats->mallocSizeOf_, &info);
+
+  rtStats->runtime.scriptSourceInfo.add(info);
+
+  if (granularity == FineGrained) {
+    const char* filename = ss->filename();
+    if (!filename) {
+      filename = "<no filename>";
+    }
+
+    JS::RuntimeSizes::ScriptSourcesHashMap::AddPtr p =
+        rtStats->runtime.allScriptSources->lookupForAdd(filename);
+    if (!p) {
+      bool ok = rtStats->runtime.allScriptSources->add(p, filename, info);
+      // Ignore failure -- we just won't record the script source as notable.
+      (void)ok;
+    } else {
+      p->value().add(info);
+    }
+  }
+}
+
+// The various kinds of hashing are expensive, and the results are unused when
+// doing coarse-grained measurements. Skipping them more than doubles the
+// profile speed for complex pages such as gmail.com.
+template <Granularity granularity>
+static void StatsCellCallback(JSRuntime* rt, void* data, JS::GCCellPtr cellptr,
+                              size_t thingSize,
+                              const JS::AutoRequireNoGC& nogc) {
+  StatsClosure* closure = static_cast<StatsClosure*>(data);
+  RuntimeStats* rtStats = closure->rtStats;
+  ZoneStats* zStats = rtStats->currZoneStats;
+  JS::TraceKind kind = cellptr.kind();
+  switch (kind) {
+    case JS::TraceKind::Object: {
+      JSObject* obj = &cellptr.as<JSObject>();
+      RealmStats& realmStats = obj->maybeCCWRealm()->realmStats();
+      JS::ClassInfo info;  // This zeroes all the sizes.
+      info.objectsGCHeap += thingSize;
+
+      if (!obj->isTenured()) {
+        info.objectsGCHeap += Nursery::nurseryCellHeaderSize();
+      }
+
+      obj->addSizeOfExcludingThis(rtStats->mallocSizeOf_, &info);
+
+      // These classes require special handling due to shared resources which
+      // we must be careful not to report twice.
+      if (obj->is<WasmModuleObject>()) {
+        const wasm::Module& module = obj->as<WasmModuleObject>().module();
+        if (ScriptSource* ss = module.metadata().maybeScriptSource()) {
+          CollectScriptSourceStats<granularity>(closure, ss);
+        }
+        module.addSizeOfMisc(rtStats->mallocSizeOf_, &closure->wasmSeenMetadata,
+                             &closure->wasmSeenCode,
+                             &info.objectsNonHeapCodeWasm,
+                             &info.objectsMallocHeapMisc);
+      } else if (obj->is<WasmInstanceObject>()) {
+        wasm::Instance& instance = obj->as<WasmInstanceObject>().instance();
+        if (ScriptSource* ss = instance.metadata().maybeScriptSource()) {
+          CollectScriptSourceStats<granularity>(closure, ss);
+        }
+        instance.addSizeOfMisc(
+            rtStats->mallocSizeOf_, &closure->wasmSeenMetadata,
+            &closure->wasmSeenCode, &closure->wasmSeenTables,
+            &info.objectsNonHeapCodeWasm, &info.objectsMallocHeapMisc);
+      }
+
+      realmStats.classInfo.add(info);
+
+      const JSClass* clasp = obj->getClass();
+      const char* className = clasp->name;
+      AddClassInfo(granularity, realmStats, className, info);
+
+      if (ObjectPrivateVisitor* opv = closure->opv) {
+        nsISupports* iface;
+        if (opv->getISupports_(obj, &iface) && iface) {
+          realmStats.objectsPrivate += opv->sizeOfIncludingThis(iface);
+        }
+      }
+      break;
+    }
+
+    case JS::TraceKind::Script: {
+      BaseScript* base = &cellptr.as<BaseScript>();
+      RealmStats& realmStats = base->realm()->realmStats();
+      realmStats.scriptsGCHeap += thingSize;
+      realmStats.scriptsMallocHeapData +=
+          base->sizeOfExcludingThis(rtStats->mallocSizeOf_);
+      if (base->hasJitScript()) {
+        JSScript* script = static_cast<JSScript*>(base);
+        script->addSizeOfJitScript(rtStats->mallocSizeOf_,
+                                   &realmStats.jitScripts,
+                                   &realmStats.baselineStubsFallback);
+        jit::AddSizeOfBaselineData(script, rtStats->mallocSizeOf_,
+                                   &realmStats.baselineData);
+        realmStats.ionData +=
+            jit::SizeOfIonData(script, rtStats->mallocSizeOf_);
+      }
+      CollectScriptSourceStats<granularity>(closure, base->scriptSource());
+      break;
+    }
+
+    case JS::TraceKind::String: {
+      JSString* str = &cellptr.as<JSString>();
+      size_t size = thingSize;
+      if (!str->isTenured()) {
+        size += Nursery::nurseryCellHeaderSize();
+      }
+
+      JS::StringInfo info;
+      if (str->hasLatin1Chars()) {
+        info.gcHeapLatin1 = size;
+        info.mallocHeapLatin1 =
+            str->sizeOfExcludingThis(rtStats->mallocSizeOf_);
+      } else {
+        info.gcHeapTwoByte = size;
+        info.mallocHeapTwoByte =
+            str->sizeOfExcludingThis(rtStats->mallocSizeOf_);
+      }
+      info.numCopies = 1;
+
+      zStats->stringInfo.add(info);
+
+      // The primary use case for anonymization is automated crash submission
+      // (to help detect OOM crashes). In that case, we don't want to pay the
+      // memory cost required to do notable string detection.
+      if (granularity == FineGrained && !closure->anonymize) {
+        ZoneStats::StringsHashMap::AddPtr p =
+            zStats->allStrings->lookupForAdd(str);
+        if (!p) {
+          bool ok = zStats->allStrings->add(p, str, info);
+          // Ignore failure -- we just won't record the string as notable.
+          (void)ok;
+        } else {
+          p->value().add(info);
+        }
+      }
+      break;
+    }
+
+    case JS::TraceKind::Symbol:
+      zStats->symbolsGCHeap += thingSize;
+      break;
+
+    case JS::TraceKind::BigInt: {
+      JS::BigInt* bi = &cellptr.as<BigInt>();
+      size_t size = thingSize;
+      if (!bi->isTenured()) {
+        size += Nursery::nurseryCellHeaderSize();
+      }
+      zStats->bigIntsGCHeap += size;
+      zStats->bigIntsMallocHeap +=
+          bi->sizeOfExcludingThis(rtStats->mallocSizeOf_);
+      break;
+    }
+
+    case JS::TraceKind::BaseShape: {
+      JS::ShapeInfo info;  // This zeroes all the sizes.
+      info.shapesGCHeapBase += thingSize;
+      // No malloc-heap measurements.
+
+      zStats->shapeInfo.add(info);
+      break;
+    }
+
+    case JS::TraceKind::JitCode: {
+      zStats->jitCodesGCHeap += thingSize;
+      // The code for a script is counted in ExecutableAllocator::sizeOfCode().
+      break;
+    }
+
+    case JS::TraceKind::Shape: {
+      Shape* shape = &cellptr.as<Shape>();
+
+      JS::ShapeInfo info;  // This zeroes all the sizes.
+      if (shape->inDictionary()) {
+        info.shapesGCHeapDict += thingSize;
+      } else {
+        info.shapesGCHeapTree += thingSize;
+      }
+      shape->addSizeOfExcludingThis(rtStats->mallocSizeOf_, &info);
+      zStats->shapeInfo.add(info);
+      break;
+    }
+
+    case JS::TraceKind::ObjectGroup: {
+      zStats->objectGroupsGCHeap += thingSize;
+      break;
+    }
+
+    case JS::TraceKind::Scope: {
+      Scope* scope = &cellptr.as<Scope>();
+      zStats->scopesGCHeap += thingSize;
+      zStats->scopesMallocHeap +=
+          scope->sizeOfExcludingThis(rtStats->mallocSizeOf_);
+      break;
+    }
+
+    case JS::TraceKind::RegExpShared: {
+      auto regexp = &cellptr.as<RegExpShared>();
+      zStats->regExpSharedsGCHeap += thingSize;
+      zStats->regExpSharedsMallocHeap +=
+          regexp->sizeOfExcludingThis(rtStats->mallocSizeOf_);
+      break;
+    }
+
+    default:
+      MOZ_CRASH("invalid traceKind in StatsCellCallback");
+  }
+
+  // Yes, this is a subtraction:  see StatsArenaCallback() for details.
+  zStats->unusedGCThings.addToKind(kind, -thingSize);
+}
+
+void ZoneStats::initStrings() {
+  isTotals = false;
+  allStrings.emplace();
+}
+
+void RealmStats::initClasses() {
+  isTotals = false;
+  allClasses.emplace();
+}
+
+static bool FindNotableStrings(ZoneStats& zStats) {
+  using namespace JS;
+
+  // We should only run FindNotableStrings once per ZoneStats object.
+  MOZ_ASSERT(zStats.notableStrings.empty());
+
+  for (ZoneStats::StringsHashMap::Range r = zStats.allStrings->all();
+       !r.empty(); r.popFront()) {
+    JSString* str = r.front().key();
+    StringInfo& info = r.front().value();
+
+    if (!info.isNotable()) {
+      continue;
+    }
+
+    if (!zStats.notableStrings.emplaceBack(str, info)) {
+      return false;
+    }
+
+    // We're moving this string from a non-notable to a notable bucket, so
+    // subtract it out of the non-notable tallies.
+    zStats.stringInfo.subtract(info);
+  }
+  // Release |allStrings| now, rather than waiting for zStats's destruction, to
+  // reduce peak memory consumption during reporting.
+  zStats.allStrings.reset();
+  return true;
+}
+
+static bool FindNotableClasses(RealmStats& realmStats) {
+  using namespace JS;
+
+  // We should only run FindNotableClasses once per ZoneStats object.
+  MOZ_ASSERT(realmStats.notableClasses.empty());
+
+  for (RealmStats::ClassesHashMap::Range r = realmStats.allClasses->all();
+       !r.empty(); r.popFront()) {
+    const char* className = r.front().key();
+    ClassInfo& info = r.front().value();
+
+    // If this class isn't notable, or if we can't grow the notableStrings
+    // vector, skip this string.
+    if (!info.isNotable()) {
+      continue;
+    }
+
+    if (!realmStats.notableClasses.emplaceBack(className, info)) {
+      return false;
+    }
+
+    // We're moving this class from a non-notable to a notable bucket, so
+    // subtract it out of the non-notable tallies.
+    realmStats.classInfo.subtract(info);
+  }
+  // Release |allClasses| now, rather than waiting for zStats's destruction, to
+  // reduce peak memory consumption during reporting.
+  realmStats.allClasses.reset();
+  return true;
+}
+
+static bool FindNotableScriptSources(JS::RuntimeSizes& runtime) {
+  using namespace JS;
+
+  // We should only run FindNotableScriptSources once per RuntimeSizes.
+  MOZ_ASSERT(runtime.notableScriptSources.empty());
+
+  for (RuntimeSizes::ScriptSourcesHashMap::Range r =
+           runtime.allScriptSources->all();
+       !r.empty(); r.popFront()) {
+    const char* filename = r.front().key();
+    ScriptSourceInfo& info = r.front().value();
+
+    if (!info.isNotable()) {
+      continue;
+    }
+
+    if (!runtime.notableScriptSources.emplaceBack(filename, info)) {
+      return false;
+    }
+
+    // We're moving this script source from a non-notable to a notable
+    // bucket, so subtract its sizes from the non-notable tallies.
+    runtime.scriptSourceInfo.subtract(info);
+  }
+  // Release |allScriptSources| now, rather than waiting for zStats's
+  // destruction, to reduce peak memory consumption during reporting.
+  runtime.allScriptSources.reset();
+  return true;
+}
+
+static bool CollectRuntimeStatsHelper(JSContext* cx, RuntimeStats* rtStats,
+                                      ObjectPrivateVisitor* opv, bool anonymize,
+                                      IterateCellCallback statsCellCallback) {
+  // Wait for any off-thread parsing to finish, as that currently allocates GC
+  // things.
+  JSRuntime* rt = cx->runtime();
+  WaitForOffThreadParses(rt);
+
+  // Finish any ongoing incremental GC that may change the data we're gathering
+  // and ensure that we don't do anything that could start another one.
+  gc::FinishGC(cx);
+  JS::AutoAssertNoGC nogc(cx);
+
+  // Wait for any background tasks to finish.
+  WaitForAllHelperThreads();
+
+  if (!rtStats->realmStatsVector.reserve(rt->numRealms)) {
+    return false;
+  }
+
+  size_t totalZones = rt->gc.zones().length() + 1;  // + 1 for the atoms zone.
+  if (!rtStats->zoneStatsVector.reserve(totalZones)) {
+    return false;
+  }
+
+  rtStats->gcHeapChunkTotal =
+      size_t(JS_GetGCParameter(cx, JSGC_TOTAL_CHUNKS)) * gc::ChunkSize;
+
+  rtStats->gcHeapUnusedChunks =
+      size_t(JS_GetGCParameter(cx, JSGC_UNUSED_CHUNKS)) * gc::ChunkSize;
+
+  IterateChunks(cx, &rtStats->gcHeapDecommittedArenas,
+                DecommittedArenasChunkCallback);
+
+  // Take the per-compartment measurements.
+  StatsClosure closure(rtStats, opv, anonymize);
+  IterateHeapUnbarriered(cx, &closure, StatsZoneCallback, StatsRealmCallback,
+                         StatsArenaCallback, statsCellCallback);
+
+  // Take the "explicit/js/runtime/" measurements.
+  rt->addSizeOfIncludingThis(rtStats->mallocSizeOf_, &rtStats->runtime);
+
+  if (!FindNotableScriptSources(rtStats->runtime)) {
+    return false;
+  }
+
+  JS::ZoneStatsVector& zs = rtStats->zoneStatsVector;
+  ZoneStats& zTotals = rtStats->zTotals;
+
+  // We don't look for notable strings for zTotals. So we first sum all the
+  // zones' measurements to get the totals. Then we find the notable strings
+  // within each zone.
+  for (size_t i = 0; i < zs.length(); i++) {
+    zTotals.addSizes(zs[i]);
+  }
+
+  for (size_t i = 0; i < zs.length(); i++) {
+    if (!FindNotableStrings(zs[i])) {
+      return false;
+    }
+  }
+
+  MOZ_ASSERT(!zTotals.allStrings);
+
+  JS::RealmStatsVector& realmStats = rtStats->realmStatsVector;
+  RealmStats& realmTotals = rtStats->realmTotals;
+
+  // As with the zones, we sum all realms first, and then get the
+  // notable classes within each zone.
+  for (size_t i = 0; i < realmStats.length(); i++) {
+    realmTotals.addSizes(realmStats[i]);
+  }
+
+  for (size_t i = 0; i < realmStats.length(); i++) {
+    if (!FindNotableClasses(realmStats[i])) {
+      return false;
+    }
+  }
+
+  MOZ_ASSERT(!realmTotals.allClasses);
+
+  rtStats->gcHeapGCThings = rtStats->zTotals.sizeOfLiveGCThings() +
+                            rtStats->realmTotals.sizeOfLiveGCThings();
+
+#ifdef DEBUG
+  // Check that the in-arena measurements look ok.
+  size_t totalArenaSize = rtStats->zTotals.gcHeapArenaAdmin +
+                          rtStats->zTotals.unusedGCThings.totalSize() +
+                          rtStats->gcHeapGCThings;
+  MOZ_ASSERT(totalArenaSize % gc::ArenaSize == 0);
+#endif
+
+  for (RealmsIter realm(rt); !realm.done(); realm.next()) {
+    realm->nullRealmStats();
+  }
+
+  size_t numDirtyChunks =
+      (rtStats->gcHeapChunkTotal - rtStats->gcHeapUnusedChunks) / gc::ChunkSize;
+  size_t perChunkAdmin =
+      sizeof(gc::TenuredChunk) - (sizeof(gc::Arena) * gc::ArenasPerChunk);
+  rtStats->gcHeapChunkAdmin = numDirtyChunks * perChunkAdmin;
+
+  // |gcHeapUnusedArenas| is the only thing left.  Compute it in terms of
+  // all the others.  See the comment in RuntimeStats for explanation.
+  rtStats->gcHeapUnusedArenas =
+      rtStats->gcHeapChunkTotal - rtStats->gcHeapDecommittedArenas -
+      rtStats->gcHeapUnusedChunks -
+      rtStats->zTotals.unusedGCThings.totalSize() - rtStats->gcHeapChunkAdmin -
+      rtStats->zTotals.gcHeapArenaAdmin - rtStats->gcHeapGCThings;
+  return true;
+}
+
+JS_PUBLIC_API bool JS::CollectGlobalStats(GlobalStats* gStats) {
+  AutoLockHelperThreadState lock;
+
+  // HelperThreadState holds data that is not part of a Runtime. This does
+  // not include data is is currently being processed by a HelperThread.
+  HelperThreadState().addSizeOfIncludingThis(gStats, lock);
+
+#ifdef JS_TRACE_LOGGING
+  // Global data used by TraceLogger
+  gStats->tracelogger += SizeOfTraceLogState(gStats->mallocSizeOf_);
+  gStats->tracelogger += SizeOfTraceLogGraphState(gStats->mallocSizeOf_);
+#endif
+
+  return true;
+}
+
+JS_PUBLIC_API bool JS::CollectRuntimeStats(JSContext* cx, RuntimeStats* rtStats,
+                                           ObjectPrivateVisitor* opv,
+                                           bool anonymize) {
+  return CollectRuntimeStatsHelper(cx, rtStats, opv, anonymize,
+                                   StatsCellCallback<FineGrained>);
+}
+
+JS_PUBLIC_API size_t JS::SystemCompartmentCount(JSContext* cx) {
+  size_t n = 0;
+  for (CompartmentsIter comp(cx->runtime()); !comp.done(); comp.next()) {
+    if (IsSystemCompartment(comp)) {
+      ++n;
+    }
+  }
+  return n;
+}
+
+JS_PUBLIC_API size_t JS::UserCompartmentCount(JSContext* cx) {
+  size_t n = 0;
+  for (CompartmentsIter comp(cx->runtime()); !comp.done(); comp.next()) {
+    if (!IsSystemCompartment(comp)) {
+      ++n;
+    }
+  }
+  return n;
+}
+
+JS_PUBLIC_API size_t JS::SystemRealmCount(JSContext* cx) {
+  size_t n = 0;
+  for (RealmsIter realm(cx->runtime()); !realm.done(); realm.next()) {
+    if (realm->isSystem()) {
+      ++n;
+    }
+  }
+  return n;
+}
+
+JS_PUBLIC_API size_t JS::UserRealmCount(JSContext* cx) {
+  size_t n = 0;
+  for (RealmsIter realm(cx->runtime()); !realm.done(); realm.next()) {
+    if (!realm->isSystem()) {
+      ++n;
+    }
+  }
+  return n;
+}
+
+JS_PUBLIC_API size_t JS::PeakSizeOfTemporary(const JSContext* cx) {
+  return cx->tempLifoAlloc().peakSizeOfExcludingThis();
+}
+
+namespace JS {
+
+class SimpleJSRuntimeStats : public JS::RuntimeStats {
+ public:
+  explicit SimpleJSRuntimeStats(MallocSizeOf mallocSizeOf)
+      : JS::RuntimeStats(mallocSizeOf) {}
+
+  virtual void initExtraZoneStats(JS::Zone* zone, JS::ZoneStats* zStats,
+                                  const JS::AutoRequireNoGC& nogc) override {}
+
+  virtual void initExtraRealmStats(Realm* realm, JS::RealmStats* realmStats,
+                                   const JS::AutoRequireNoGC& nogc) override {}
+};
+
+JS_PUBLIC_API bool AddSizeOfTab(JSContext* cx, HandleObject obj,
+                                MallocSizeOf mallocSizeOf,
+                                ObjectPrivateVisitor* opv, TabSizes* sizes) {
+  SimpleJSRuntimeStats rtStats(mallocSizeOf);
+
+  JS::Zone* zone = GetObjectZone(obj);
+
+  size_t numRealms = 0;
+  for (CompartmentsInZoneIter comp(zone); !comp.done(); comp.next()) {
+    numRealms += comp->realms().length();
+  }
+
+  if (!rtStats.realmStatsVector.reserve(numRealms)) {
+    return false;
+  }
+
+  if (!rtStats.zoneStatsVector.reserve(1)) {
+    return false;
+  }
+
+  // Take the per-compartment measurements. No need to anonymize because
+  // these measurements will be aggregated.
+  StatsClosure closure(&rtStats, opv, /* anonymize = */ false);
+  IterateHeapUnbarrieredForZone(cx, zone, &closure, StatsZoneCallback,
+                                StatsRealmCallback, StatsArenaCallback,
+                                StatsCellCallback<CoarseGrained>);
+
+  MOZ_ASSERT(rtStats.zoneStatsVector.length() == 1);
+  rtStats.zTotals.addSizes(rtStats.zoneStatsVector[0]);
+
+  for (size_t i = 0; i < rtStats.realmStatsVector.length(); i++) {
+    rtStats.realmTotals.addSizes(rtStats.realmStatsVector[i]);
+  }
+
+  for (RealmsInZoneIter realm(zone); !realm.done(); realm.next()) {
+    realm->nullRealmStats();
+  }
+
+  rtStats.zTotals.addToTabSizes(sizes);
+  rtStats.realmTotals.addToTabSizes(sizes);
+
+  return true;
+}
+
+JS_PUBLIC_API bool AddServoSizeOf(JSContext* cx, MallocSizeOf mallocSizeOf,
+                                  ObjectPrivateVisitor* opv,
+                                  ServoSizes* sizes) {
+  SimpleJSRuntimeStats rtStats(mallocSizeOf);
+
+  // No need to anonymize because the results will be aggregated.
+  if (!CollectRuntimeStatsHelper(cx, &rtStats, opv, /* anonymize = */ false,
+                                 StatsCellCallback<CoarseGrained>))
+    return false;
+
+#ifdef DEBUG
+  size_t gcHeapTotalOriginal = sizes->gcHeapUsed + sizes->gcHeapUnused +
+                               sizes->gcHeapAdmin + sizes->gcHeapDecommitted;
+#endif
+
+  rtStats.addToServoSizes(sizes);
+  rtStats.zTotals.addToServoSizes(sizes);
+  rtStats.realmTotals.addToServoSizes(sizes);
+
+#ifdef DEBUG
+  size_t gcHeapTotal = sizes->gcHeapUsed + sizes->gcHeapUnused +
+                       sizes->gcHeapAdmin + sizes->gcHeapDecommitted;
+  MOZ_ASSERT(rtStats.gcHeapChunkTotal == gcHeapTotal - gcHeapTotalOriginal);
+#endif
+
+  return true;
+}
+
+}  // namespace JS