mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-06-01 17:41:34 +00:00
1098 lines
35 KiB
C++
1098 lines
35 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* vim: set ts=8 sts=4 et sw=4 tw=99:
|
|
* 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/UbiNodeCensus.h"
|
|
|
|
#include "jscntxt.h"
|
|
#include "jscompartment.h"
|
|
#include "jsobjinlines.h"
|
|
|
|
using namespace js;
|
|
|
|
namespace JS {
|
|
namespace ubi {
|
|
|
|
void
|
|
CountDeleter::operator()(CountBase* ptr)
|
|
{
|
|
if (!ptr)
|
|
return;
|
|
|
|
// Downcast to our true type and destruct, as guided by our CountType
|
|
// pointer.
|
|
ptr->destruct();
|
|
js_free(ptr);
|
|
}
|
|
|
|
bool
|
|
Census::init() {
|
|
AutoLockForExclusiveAccess lock(cx);
|
|
atomsZone = cx->runtime()->atomsCompartment()->zone();
|
|
return targetZones.init();
|
|
}
|
|
|
|
|
|
/*** Count Types ***********************************************************************************/
|
|
|
|
// The simplest type: just count everything.
|
|
class SimpleCount : public CountType {
|
|
|
|
struct Count : CountBase {
|
|
size_t totalBytes_;
|
|
|
|
explicit Count(SimpleCount& count)
|
|
: CountBase(count),
|
|
totalBytes_(0)
|
|
{ }
|
|
};
|
|
|
|
UniquePtr<char16_t[], JS::FreePolicy> label;
|
|
bool reportCount : 1;
|
|
bool reportBytes : 1;
|
|
|
|
public:
|
|
SimpleCount(Census& census,
|
|
UniquePtr<char16_t[], JS::FreePolicy>& label,
|
|
bool reportCount=true,
|
|
bool reportBytes=true)
|
|
: CountType(census),
|
|
label(Move(label)),
|
|
reportCount(reportCount),
|
|
reportBytes(reportBytes)
|
|
{ }
|
|
|
|
explicit SimpleCount(Census& census)
|
|
: CountType(census),
|
|
label(nullptr),
|
|
reportCount(true),
|
|
reportBytes(true)
|
|
{ }
|
|
|
|
void destructCount(CountBase& countBase) override {
|
|
Count& count = static_cast<Count&>(countBase);
|
|
count.~Count();
|
|
}
|
|
|
|
CountBasePtr makeCount() override { return CountBasePtr(census.new_<Count>(*this)); }
|
|
void traceCount(CountBase& countBase, JSTracer* trc) override { }
|
|
bool count(CountBase& countBase, const Node& node) override;
|
|
bool report(CountBase& countBase, MutableHandleValue report) override;
|
|
};
|
|
|
|
bool
|
|
SimpleCount::count(CountBase& countBase, const Node& node)
|
|
{
|
|
Count& count = static_cast<Count&>(countBase);
|
|
count.total_++;
|
|
if (reportBytes)
|
|
count.totalBytes_ += node.size(census.cx->runtime()->debuggerMallocSizeOf);
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
SimpleCount::report(CountBase& countBase, MutableHandleValue report)
|
|
{
|
|
Count& count = static_cast<Count&>(countBase);
|
|
|
|
RootedPlainObject obj(census.cx, NewBuiltinClassInstance<PlainObject>(census.cx));
|
|
if (!obj)
|
|
return false;
|
|
|
|
RootedValue countValue(census.cx, NumberValue(count.total_));
|
|
if (reportCount && !DefineProperty(census.cx, obj, census.cx->names().count, countValue))
|
|
return false;
|
|
|
|
RootedValue bytesValue(census.cx, NumberValue(count.totalBytes_));
|
|
if (reportBytes && !DefineProperty(census.cx, obj, census.cx->names().bytes, bytesValue))
|
|
return false;
|
|
|
|
if (label) {
|
|
JSString* labelString = JS_NewUCStringCopyZ(census.cx, label.get());
|
|
if (!labelString)
|
|
return false;
|
|
RootedValue labelValue(census.cx, StringValue(labelString));
|
|
if (!DefineProperty(census.cx, obj, census.cx->names().label, labelValue))
|
|
return false;
|
|
}
|
|
|
|
report.setObject(*obj);
|
|
return true;
|
|
}
|
|
|
|
|
|
// A type that categorizes nodes by their JavaScript type -- 'objects',
|
|
// 'strings', 'scripts', and 'other' -- and then passes the nodes to child
|
|
// types.
|
|
//
|
|
// Implementation details of scripts like jitted code are counted under
|
|
// 'scripts'.
|
|
class ByCoarseType : public CountType {
|
|
CountTypePtr objects;
|
|
CountTypePtr scripts;
|
|
CountTypePtr strings;
|
|
CountTypePtr other;
|
|
|
|
struct Count : CountBase {
|
|
Count(CountType& type,
|
|
CountBasePtr& objects,
|
|
CountBasePtr& scripts,
|
|
CountBasePtr& strings,
|
|
CountBasePtr& other)
|
|
: CountBase(type),
|
|
objects(Move(objects)),
|
|
scripts(Move(scripts)),
|
|
strings(Move(strings)),
|
|
other(Move(other))
|
|
{ }
|
|
|
|
CountBasePtr objects;
|
|
CountBasePtr scripts;
|
|
CountBasePtr strings;
|
|
CountBasePtr other;
|
|
};
|
|
|
|
public:
|
|
ByCoarseType(Census& census,
|
|
CountTypePtr& objects,
|
|
CountTypePtr& scripts,
|
|
CountTypePtr& strings,
|
|
CountTypePtr& other)
|
|
: CountType(census),
|
|
objects(Move(objects)),
|
|
scripts(Move(scripts)),
|
|
strings(Move(strings)),
|
|
other(Move(other))
|
|
{ }
|
|
|
|
void destructCount(CountBase& countBase) override {
|
|
Count& count = static_cast<Count&>(countBase);
|
|
count.~Count();
|
|
}
|
|
|
|
CountBasePtr makeCount() override;
|
|
void traceCount(CountBase& countBase, JSTracer* trc) override;
|
|
bool count(CountBase& countBase, const Node& node) override;
|
|
bool report(CountBase& countBase, MutableHandleValue report) override;
|
|
};
|
|
|
|
CountBasePtr
|
|
ByCoarseType::makeCount()
|
|
{
|
|
CountBasePtr objectsCount(objects->makeCount());
|
|
CountBasePtr scriptsCount(scripts->makeCount());
|
|
CountBasePtr stringsCount(strings->makeCount());
|
|
CountBasePtr otherCount(other->makeCount());
|
|
|
|
if (!objectsCount || !scriptsCount || !stringsCount || !otherCount)
|
|
return CountBasePtr(nullptr);
|
|
|
|
return CountBasePtr(census.new_<Count>(*this,
|
|
objectsCount,
|
|
scriptsCount,
|
|
stringsCount,
|
|
otherCount));
|
|
}
|
|
|
|
void
|
|
ByCoarseType::traceCount(CountBase& countBase, JSTracer* trc)
|
|
{
|
|
Count& count = static_cast<Count&>(countBase);
|
|
count.objects->trace(trc);
|
|
count.scripts->trace(trc);
|
|
count.strings->trace(trc);
|
|
count.other->trace(trc);
|
|
}
|
|
|
|
bool
|
|
ByCoarseType::count(CountBase& countBase, const Node& node)
|
|
{
|
|
Count& count = static_cast<Count&>(countBase);
|
|
count.total_++;
|
|
|
|
switch (node.coarseType()) {
|
|
case JS::ubi::CoarseType::Object:
|
|
return count.objects->count(node);
|
|
case JS::ubi::CoarseType::Script:
|
|
return count.scripts->count(node);
|
|
case JS::ubi::CoarseType::String:
|
|
return count.strings->count(node);
|
|
case JS::ubi::CoarseType::Other:
|
|
return count.other->count(node);
|
|
default:
|
|
MOZ_CRASH("bad JS::ubi::CoarseType in JS::ubi::ByCoarseType::count");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool
|
|
ByCoarseType::report(CountBase& countBase, MutableHandleValue report)
|
|
{
|
|
Count& count = static_cast<Count&>(countBase);
|
|
JSContext* cx = census.cx;
|
|
|
|
RootedPlainObject obj(cx, NewBuiltinClassInstance<PlainObject>(cx));
|
|
if (!obj)
|
|
return false;
|
|
|
|
RootedValue objectsReport(cx);
|
|
if (!count.objects->report(&objectsReport) ||
|
|
!DefineProperty(cx, obj, cx->names().objects, objectsReport))
|
|
return false;
|
|
|
|
RootedValue scriptsReport(cx);
|
|
if (!count.scripts->report(&scriptsReport) ||
|
|
!DefineProperty(cx, obj, cx->names().scripts, scriptsReport))
|
|
return false;
|
|
|
|
RootedValue stringsReport(cx);
|
|
if (!count.strings->report(&stringsReport) ||
|
|
!DefineProperty(cx, obj, cx->names().strings, stringsReport))
|
|
return false;
|
|
|
|
RootedValue otherReport(cx);
|
|
if (!count.other->report(&otherReport) ||
|
|
!DefineProperty(cx, obj, cx->names().other, otherReport))
|
|
return false;
|
|
|
|
report.setObject(*obj);
|
|
return true;
|
|
}
|
|
|
|
|
|
// Comparison function for sorting hash table entries by total count. The
|
|
// arguments are doubly indirect: they're pointers to elements in an array of
|
|
// pointers to table entries.
|
|
template<typename Entry>
|
|
static int compareEntries(const void* lhsVoid, const void* rhsVoid) {
|
|
size_t lhs = (*static_cast<const Entry* const*>(lhsVoid))->value()->total_;
|
|
size_t rhs = (*static_cast<const Entry* const*>(rhsVoid))->value()->total_;
|
|
|
|
// qsort sorts in "ascending" order, so we should describe entries with
|
|
// smaller counts as being "greater than" entries with larger counts. We
|
|
// don't want to just subtract the counts, as they're unsigned.
|
|
if (lhs < rhs)
|
|
return 1;
|
|
if (lhs > rhs)
|
|
return -1;
|
|
return 0;
|
|
}
|
|
|
|
// A hash policy that compares C strings.
|
|
struct CStringHashPolicy {
|
|
using Lookup = const char*;
|
|
static js::HashNumber hash(Lookup l) { return mozilla::HashString(l); }
|
|
static bool match(const char* key, Lookup lookup) {
|
|
return strcmp(key, lookup) == 0;
|
|
}
|
|
};
|
|
|
|
// A hash map mapping from C strings to counts.
|
|
using CStringCountMap = HashMap<const char*, CountBasePtr, CStringHashPolicy, SystemAllocPolicy>;
|
|
|
|
// Convert a CStringCountMap into an object with each key one of the c strings
|
|
// from the map and each value the associated count's report. For use with
|
|
// reporting.
|
|
static PlainObject*
|
|
cStringCountMapToObject(JSContext* cx, CStringCountMap& map) {
|
|
// Build a vector of pointers to entries; sort by total; and then use
|
|
// that to build the result object. This makes the ordering of entries
|
|
// more interesting, and a little less non-deterministic.
|
|
|
|
mozilla::Vector<CStringCountMap::Entry*> entries;
|
|
if (!entries.reserve(map.count())) {
|
|
ReportOutOfMemory(cx);
|
|
return nullptr;
|
|
}
|
|
|
|
for (auto r = map.all(); !r.empty(); r.popFront())
|
|
entries.infallibleAppend(&r.front());
|
|
|
|
qsort(entries.begin(), entries.length(), sizeof(*entries.begin()),
|
|
compareEntries<CStringCountMap::Entry>);
|
|
|
|
RootedPlainObject obj(cx, NewBuiltinClassInstance<PlainObject>(cx));
|
|
if (!obj)
|
|
return nullptr;
|
|
|
|
for (auto& entry : entries) {
|
|
CountBasePtr& thenCount = entry->value();
|
|
RootedValue thenReport(cx);
|
|
if (!thenCount->report(&thenReport))
|
|
return nullptr;
|
|
|
|
const char* name = entry->key();
|
|
MOZ_ASSERT(name);
|
|
JSAtom* atom = Atomize(cx, name, strlen(name));
|
|
if (!atom)
|
|
return nullptr;
|
|
|
|
RootedId entryId(cx, AtomToId(atom));
|
|
if (!DefineProperty(cx, obj, entryId, thenReport))
|
|
return nullptr;
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
|
|
|
|
// A type that categorizes nodes that are JSObjects by their class name,
|
|
// and places all other nodes in an 'other' category.
|
|
class ByObjectClass : public CountType {
|
|
// A table mapping class names to their counts. Note that we treat js::Class
|
|
// instances with the same name as equal keys. If you have several
|
|
// js::Classes with equal names (and we do; as of this writing there were
|
|
// six named "Object"), you will get several different js::Classes being
|
|
// counted in the same table entry.
|
|
using Table = CStringCountMap;
|
|
using Entry = Table::Entry;
|
|
|
|
struct Count : public CountBase {
|
|
Table table;
|
|
CountBasePtr other;
|
|
|
|
Count(CountType& type, CountBasePtr& other)
|
|
: CountBase(type),
|
|
other(Move(other))
|
|
{ }
|
|
|
|
bool init() { return table.init(); }
|
|
};
|
|
|
|
CountTypePtr classesType;
|
|
CountTypePtr otherType;
|
|
|
|
public:
|
|
ByObjectClass(Census& census,
|
|
CountTypePtr& classesType,
|
|
CountTypePtr& otherType)
|
|
: CountType(census),
|
|
classesType(Move(classesType)),
|
|
otherType(Move(otherType))
|
|
{ }
|
|
|
|
void destructCount(CountBase& countBase) override {
|
|
Count& count = static_cast<Count&>(countBase);
|
|
count.~Count();
|
|
}
|
|
|
|
CountBasePtr makeCount() override;
|
|
void traceCount(CountBase& countBase, JSTracer* trc) override;
|
|
bool count(CountBase& countBase, const Node& node) override;
|
|
bool report(CountBase& countBase, MutableHandleValue report) override;
|
|
};
|
|
|
|
CountBasePtr
|
|
ByObjectClass::makeCount()
|
|
{
|
|
CountBasePtr otherCount(otherType->makeCount());
|
|
if (!otherCount)
|
|
return nullptr;
|
|
|
|
UniquePtr<Count> count(census.new_<Count>(*this, otherCount));
|
|
if (!count || !count->init())
|
|
return nullptr;
|
|
|
|
return CountBasePtr(count.release());
|
|
}
|
|
|
|
void
|
|
ByObjectClass::traceCount(CountBase& countBase, JSTracer* trc)
|
|
{
|
|
Count& count = static_cast<Count&>(countBase);
|
|
for (Table::Range r = count.table.all(); !r.empty(); r.popFront())
|
|
r.front().value()->trace(trc);
|
|
count.other->trace(trc);
|
|
}
|
|
|
|
bool
|
|
ByObjectClass::count(CountBase& countBase, const Node& node)
|
|
{
|
|
Count& count = static_cast<Count&>(countBase);
|
|
count.total_++;
|
|
|
|
const char* className = node.jsObjectClassName();
|
|
if (!className)
|
|
return count.other->count(node);
|
|
|
|
Table::AddPtr p = count.table.lookupForAdd(className);
|
|
if (!p) {
|
|
CountBasePtr classCount(classesType->makeCount());
|
|
if (!classCount || !count.table.add(p, className, Move(classCount)))
|
|
return false;
|
|
}
|
|
return p->value()->count(node);
|
|
}
|
|
|
|
bool
|
|
ByObjectClass::report(CountBase& countBase, MutableHandleValue report)
|
|
{
|
|
Count& count = static_cast<Count&>(countBase);
|
|
JSContext* cx = census.cx;
|
|
|
|
RootedPlainObject obj(cx, cStringCountMapToObject(cx, count.table));
|
|
if (!obj)
|
|
return false;
|
|
|
|
RootedValue otherReport(cx);
|
|
if (!count.other->report(&otherReport) ||
|
|
!DefineProperty(cx, obj, cx->names().other, otherReport))
|
|
return false;
|
|
|
|
report.setObject(*obj);
|
|
return true;
|
|
}
|
|
|
|
|
|
// A count type that categorizes nodes by their ubi::Node::typeName.
|
|
class ByUbinodeType : public CountType {
|
|
// Note that, because ubi::Node::typeName promises to return a specific
|
|
// pointer, not just any string whose contents are correct, we can use their
|
|
// addresses as hash table keys.
|
|
using Table = HashMap<const char16_t*, CountBasePtr, DefaultHasher<const char16_t*>,
|
|
SystemAllocPolicy>;
|
|
using Entry = Table::Entry;
|
|
|
|
struct Count: public CountBase {
|
|
Table table;
|
|
|
|
explicit Count(CountType& type) : CountBase(type) { }
|
|
|
|
bool init() { return table.init(); }
|
|
};
|
|
|
|
CountTypePtr entryType;
|
|
|
|
public:
|
|
ByUbinodeType(Census& census, CountTypePtr& entryType)
|
|
: CountType(census),
|
|
entryType(Move(entryType))
|
|
{ }
|
|
|
|
void destructCount(CountBase& countBase) override {
|
|
Count& count = static_cast<Count&>(countBase);
|
|
count.~Count();
|
|
}
|
|
|
|
CountBasePtr makeCount() override;
|
|
void traceCount(CountBase& countBase, JSTracer* trc) override;
|
|
bool count(CountBase& countBase, const Node& node) override;
|
|
bool report(CountBase& countBase, MutableHandleValue report) override;
|
|
};
|
|
|
|
CountBasePtr
|
|
ByUbinodeType::makeCount()
|
|
{
|
|
UniquePtr<Count> count(census.new_<Count>(*this));
|
|
if (!count || !count->init())
|
|
return nullptr;
|
|
|
|
return CountBasePtr(count.release());
|
|
}
|
|
|
|
void
|
|
ByUbinodeType::traceCount(CountBase& countBase, JSTracer* trc)
|
|
{
|
|
Count& count = static_cast<Count&>(countBase);
|
|
for (Table::Range r = count.table.all(); !r.empty(); r.popFront())
|
|
r.front().value()->trace(trc);
|
|
}
|
|
|
|
bool
|
|
ByUbinodeType::count(CountBase& countBase, const Node& node)
|
|
{
|
|
Count& count = static_cast<Count&>(countBase);
|
|
count.total_++;
|
|
|
|
const char16_t* key = node.typeName();
|
|
MOZ_ASSERT(key);
|
|
Table::AddPtr p = count.table.lookupForAdd(key);
|
|
if (!p) {
|
|
CountBasePtr typesCount(entryType->makeCount());
|
|
if (!typesCount || !count.table.add(p, key, Move(typesCount)))
|
|
return false;
|
|
}
|
|
return p->value()->count(node);
|
|
}
|
|
|
|
bool
|
|
ByUbinodeType::report(CountBase& countBase, MutableHandleValue report)
|
|
{
|
|
Count& count = static_cast<Count&>(countBase);
|
|
JSContext* cx = census.cx;
|
|
|
|
// Build a vector of pointers to entries; sort by total; and then use
|
|
// that to build the result object. This makes the ordering of entries
|
|
// more interesting, and a little less non-deterministic.
|
|
mozilla::Vector<Entry*> entries;
|
|
if (!entries.reserve(count.table.count()))
|
|
return false;
|
|
for (Table::Range r = count.table.all(); !r.empty(); r.popFront())
|
|
entries.infallibleAppend(&r.front());
|
|
qsort(entries.begin(), entries.length(), sizeof(*entries.begin()), compareEntries<Entry>);
|
|
|
|
// Now build the result by iterating over the sorted vector.
|
|
RootedPlainObject obj(cx, NewBuiltinClassInstance<PlainObject>(cx));
|
|
if (!obj)
|
|
return false;
|
|
for (Entry** entryPtr = entries.begin(); entryPtr < entries.end(); entryPtr++) {
|
|
Entry& entry = **entryPtr;
|
|
CountBasePtr& typeCount = entry.value();
|
|
RootedValue typeReport(cx);
|
|
if (!typeCount->report(&typeReport))
|
|
return false;
|
|
|
|
const char16_t* name = entry.key();
|
|
MOZ_ASSERT(name);
|
|
JSAtom* atom = AtomizeChars(cx, name, js_strlen(name));
|
|
if (!atom)
|
|
return false;
|
|
RootedId entryId(cx, AtomToId(atom));
|
|
|
|
if (!DefineProperty(cx, obj, entryId, typeReport))
|
|
return false;
|
|
}
|
|
|
|
report.setObject(*obj);
|
|
return true;
|
|
}
|
|
|
|
|
|
// A count type that categorizes nodes by the JS stack under which they were
|
|
// allocated.
|
|
class ByAllocationStack : public CountType {
|
|
using Table = HashMap<StackFrame, CountBasePtr, DefaultHasher<StackFrame>,
|
|
SystemAllocPolicy>;
|
|
using Entry = Table::Entry;
|
|
|
|
struct Count : public CountBase {
|
|
// NOTE: You may look up entries in this table by JS::ubi::StackFrame
|
|
// key only during traversal, NOT ONCE TRAVERSAL IS COMPLETE. Once
|
|
// traversal is complete, you may only iterate over it.
|
|
//
|
|
// In this hash table, keys are JSObjects (with some indirection), and
|
|
// we use JSObject identity (that is, address identity) as key
|
|
// identity. The normal way to support such a table is to make the trace
|
|
// function notice keys that have moved and re-key them in the
|
|
// table. However, our trace function does *not* rehash; the first GC
|
|
// may render the hash table unsearchable.
|
|
//
|
|
// This is as it should be:
|
|
//
|
|
// First, the heap traversal phase needs lookups by key to work. But no
|
|
// GC may ever occur during a traversal; this is enforced by the
|
|
// JS::ubi::BreadthFirst template. So the traceCount function doesn't
|
|
// need to do anything to help traversal; it never even runs then.
|
|
//
|
|
// Second, the report phase needs iteration over the table to work, but
|
|
// never looks up entries by key. GC may well occur during this phase:
|
|
// we allocate a Map object, and probably cross-compartment wrappers for
|
|
// SavedFrame instances as well. If a GC were to occur, it would call
|
|
// our traceCount function; if traceCount were to re-key, that would
|
|
// ruin the traversal in progress.
|
|
//
|
|
// So depending on the phase, we either don't need re-keying, or
|
|
// can't abide it.
|
|
Table table;
|
|
CountBasePtr noStack;
|
|
|
|
Count(CountType& type, CountBasePtr& noStack)
|
|
: CountBase(type),
|
|
noStack(Move(noStack))
|
|
{ }
|
|
bool init() { return table.init(); }
|
|
};
|
|
|
|
CountTypePtr entryType;
|
|
CountTypePtr noStackType;
|
|
|
|
public:
|
|
ByAllocationStack(Census& census, CountTypePtr& entryType, CountTypePtr& noStackType)
|
|
: CountType(census),
|
|
entryType(Move(entryType)),
|
|
noStackType(Move(noStackType))
|
|
{ }
|
|
|
|
void destructCount(CountBase& countBase) override {
|
|
Count& count = static_cast<Count&>(countBase);
|
|
count.~Count();
|
|
}
|
|
|
|
CountBasePtr makeCount() override;
|
|
void traceCount(CountBase& countBase, JSTracer* trc) override;
|
|
bool count(CountBase& countBase, const Node& node) override;
|
|
bool report(CountBase& countBase, MutableHandleValue report) override;
|
|
};
|
|
|
|
CountBasePtr
|
|
ByAllocationStack::makeCount()
|
|
{
|
|
CountBasePtr noStackCount(noStackType->makeCount());
|
|
if (!noStackCount)
|
|
return nullptr;
|
|
|
|
UniquePtr<Count> count(census.new_<Count>(*this, noStackCount));
|
|
if (!count || !count->init())
|
|
return nullptr;
|
|
return CountBasePtr(count.release());
|
|
}
|
|
|
|
void
|
|
ByAllocationStack::traceCount(CountBase& countBase, JSTracer* trc)
|
|
{
|
|
Count& count = static_cast<Count&>(countBase);
|
|
for (Table::Range r = count.table.all(); !r.empty(); r.popFront()) {
|
|
// Trace our child Counts.
|
|
r.front().value()->trace(trc);
|
|
|
|
// Trace the StackFrame that is this entry's key. Do not re-key if
|
|
// it has moved; see comments for ByAllocationStack::Count::table.
|
|
const StackFrame* key = &r.front().key();
|
|
auto& k = *const_cast<StackFrame*>(key);
|
|
k.trace(trc);
|
|
}
|
|
count.noStack->trace(trc);
|
|
}
|
|
|
|
bool
|
|
ByAllocationStack::count(CountBase& countBase, const Node& node)
|
|
{
|
|
Count& count = static_cast<Count&>(countBase);
|
|
count.total_++;
|
|
|
|
// If we do have an allocation stack for this node, include it in the
|
|
// count for that stack.
|
|
if (node.hasAllocationStack()) {
|
|
auto allocationStack = node.allocationStack();
|
|
auto p = count.table.lookupForAdd(allocationStack);
|
|
if (!p) {
|
|
CountBasePtr stackCount(entryType->makeCount());
|
|
if (!stackCount || !count.table.add(p, allocationStack, Move(stackCount)))
|
|
return false;
|
|
}
|
|
MOZ_ASSERT(p);
|
|
return p->value()->count(node);
|
|
}
|
|
|
|
// Otherwise, count it in the "no stack" category.
|
|
return count.noStack->count(node);
|
|
}
|
|
|
|
bool
|
|
ByAllocationStack::report(CountBase& countBase, MutableHandleValue report)
|
|
{
|
|
Count& count = static_cast<Count&>(countBase);
|
|
JSContext* cx = census.cx;
|
|
|
|
#ifdef DEBUG
|
|
// Check that nothing rehashes our table while we hold pointers into it.
|
|
Generation generation = count.table.generation();
|
|
#endif
|
|
|
|
// Build a vector of pointers to entries; sort by total; and then use
|
|
// that to build the result object. This makes the ordering of entries
|
|
// more interesting, and a little less non-deterministic.
|
|
mozilla::Vector<Entry*> entries;
|
|
if (!entries.reserve(count.table.count()))
|
|
return false;
|
|
for (Table::Range r = count.table.all(); !r.empty(); r.popFront())
|
|
entries.infallibleAppend(&r.front());
|
|
qsort(entries.begin(), entries.length(), sizeof(*entries.begin()), compareEntries<Entry>);
|
|
|
|
// Now build the result by iterating over the sorted vector.
|
|
Rooted<MapObject*> map(cx, MapObject::create(cx));
|
|
if (!map)
|
|
return false;
|
|
for (Entry** entryPtr = entries.begin(); entryPtr < entries.end(); entryPtr++) {
|
|
Entry& entry = **entryPtr;
|
|
MOZ_ASSERT(entry.key());
|
|
|
|
RootedObject stack(cx);
|
|
if (!entry.key().constructSavedFrameStack(cx, &stack) ||
|
|
!cx->compartment()->wrap(cx, &stack))
|
|
{
|
|
return false;
|
|
}
|
|
RootedValue stackVal(cx, ObjectValue(*stack));
|
|
|
|
CountBasePtr& stackCount = entry.value();
|
|
RootedValue stackReport(cx);
|
|
if (!stackCount->report(&stackReport))
|
|
return false;
|
|
|
|
if (!MapObject::set(cx, map, stackVal, stackReport))
|
|
return false;
|
|
}
|
|
|
|
if (count.noStack->total_ > 0) {
|
|
RootedValue noStackReport(cx);
|
|
if (!count.noStack->report(&noStackReport))
|
|
return false;
|
|
RootedValue noStack(cx, StringValue(cx->names().noStack));
|
|
if (!MapObject::set(cx, map, noStack, noStackReport))
|
|
return false;
|
|
}
|
|
|
|
MOZ_ASSERT(generation == count.table.generation());
|
|
|
|
report.setObject(*map);
|
|
return true;
|
|
}
|
|
|
|
// A count type that categorizes nodes by their script's filename.
|
|
class ByFilename : public CountType {
|
|
// A table mapping filenames to their counts. Note that we treat scripts
|
|
// with the same filename as equivalent. If you have several sources with
|
|
// the same filename, then all their scripts will get bucketed together.
|
|
using Table = CStringCountMap;
|
|
using Entry = Table::Entry;
|
|
|
|
struct Count : public CountBase {
|
|
Table table;
|
|
CountBasePtr then;
|
|
CountBasePtr noFilename;
|
|
|
|
Count(CountType& type, CountBasePtr&& then, CountBasePtr&& noFilename)
|
|
: CountBase(type)
|
|
, then(Move(then))
|
|
, noFilename(Move(noFilename))
|
|
{ }
|
|
|
|
bool init() { return table.init(); }
|
|
};
|
|
|
|
CountTypePtr thenType;
|
|
CountTypePtr noFilenameType;
|
|
|
|
public:
|
|
ByFilename(Census& census,
|
|
CountTypePtr& thenType,
|
|
CountTypePtr& noFilenameType)
|
|
: CountType(census),
|
|
thenType(Move(thenType)),
|
|
noFilenameType(Move(noFilenameType))
|
|
{ }
|
|
|
|
void destructCount(CountBase& countBase) override {
|
|
Count& count = static_cast<Count&>(countBase);
|
|
count.~Count();
|
|
}
|
|
|
|
CountBasePtr makeCount() override;
|
|
void traceCount(CountBase& countBase, JSTracer* trc) override;
|
|
bool count(CountBase& countBase, const Node& node) override;
|
|
bool report(CountBase& countBase, MutableHandleValue report) override;
|
|
};
|
|
|
|
CountBasePtr
|
|
ByFilename::makeCount()
|
|
{
|
|
CountBasePtr thenCount(thenType->makeCount());
|
|
if (!thenCount)
|
|
return nullptr;
|
|
|
|
CountBasePtr noFilenameCount(noFilenameType->makeCount());
|
|
if (!noFilenameCount)
|
|
return nullptr;
|
|
|
|
UniquePtr<Count> count(census.new_<Count>(*this, Move(thenCount), Move(noFilenameCount)));
|
|
if (!count || !count->init())
|
|
return nullptr;
|
|
|
|
return CountBasePtr(count.release());
|
|
}
|
|
|
|
void
|
|
ByFilename::traceCount(CountBase& countBase, JSTracer* trc)
|
|
{
|
|
Count& count = static_cast<Count&>(countBase);
|
|
for (Table::Range r = count.table.all(); !r.empty(); r.popFront())
|
|
r.front().value()->trace(trc);
|
|
count.noFilename->trace(trc);
|
|
}
|
|
|
|
bool
|
|
ByFilename::count(CountBase& countBase, const Node& node)
|
|
{
|
|
Count& count = static_cast<Count&>(countBase);
|
|
count.total_++;
|
|
|
|
const char* filename = node.scriptFilename();
|
|
if (!filename)
|
|
return count.noFilename->count(node);
|
|
|
|
Table::AddPtr p = count.table.lookupForAdd(filename);
|
|
if (!p) {
|
|
CountBasePtr thenCount(thenType->makeCount());
|
|
if (!thenCount || !count.table.add(p, filename, Move(thenCount)))
|
|
return false;
|
|
}
|
|
return p->value()->count(node);
|
|
}
|
|
|
|
bool
|
|
ByFilename::report(CountBase& countBase, MutableHandleValue report)
|
|
{
|
|
Count& count = static_cast<Count&>(countBase);
|
|
JSContext* cx = census.cx;
|
|
|
|
RootedPlainObject obj(cx, cStringCountMapToObject(cx, count.table));
|
|
if (!obj)
|
|
return false;
|
|
|
|
RootedValue noFilenameReport(cx);
|
|
if (!count.noFilename->report(&noFilenameReport) ||
|
|
!DefineProperty(cx, obj, cx->names().noFilename, noFilenameReport))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
report.setObject(*obj);
|
|
return true;
|
|
}
|
|
|
|
|
|
/*** Census Handler *******************************************************************************/
|
|
|
|
bool
|
|
CensusHandler::operator() (BreadthFirst<CensusHandler>& traversal,
|
|
Node origin, const Edge& edge,
|
|
NodeData* referentData, bool first)
|
|
{
|
|
// We're only interested in the first time we reach edge.referent, not
|
|
// in every edge arriving at that node.
|
|
if (!first)
|
|
return true;
|
|
|
|
// Don't count nodes outside the debuggee zones. Do count things in the
|
|
// special atoms zone, but don't traverse their outgoing edges, on the
|
|
// assumption that they are shared resources that debuggee is using.
|
|
// Symbols are always allocated in the atoms zone, even if they were
|
|
// created for exactly one compartment and never shared; this rule will
|
|
// include such nodes in the count.
|
|
const Node& referent = edge.referent;
|
|
Zone* zone = referent.zone();
|
|
|
|
if (census.targetZones.count() == 0 || census.targetZones.has(zone))
|
|
return rootCount->count(referent);
|
|
|
|
if (zone == census.atomsZone) {
|
|
traversal.abandonReferent();
|
|
return rootCount->count(referent);
|
|
}
|
|
|
|
traversal.abandonReferent();
|
|
return true;
|
|
}
|
|
|
|
|
|
/*** Parsing Breakdowns ***************************************************************************/
|
|
|
|
static CountTypePtr ParseBreakdown(Census& census, HandleValue breakdownValue);
|
|
|
|
static CountTypePtr
|
|
ParseChildBreakdown(Census& census, HandleObject breakdown, PropertyName* prop)
|
|
{
|
|
JSContext* cx = census.cx;
|
|
RootedValue v(cx);
|
|
if (!GetProperty(cx, breakdown, breakdown, prop, &v))
|
|
return nullptr;
|
|
return ParseBreakdown(census, v);
|
|
}
|
|
|
|
static CountTypePtr
|
|
ParseBreakdown(Census& census, HandleValue breakdownValue)
|
|
{
|
|
JSContext* cx = census.cx;
|
|
|
|
if (breakdownValue.isUndefined()) {
|
|
// Construct the default type, { by: 'count' }
|
|
CountTypePtr simple(census.new_<SimpleCount>(census));
|
|
return simple;
|
|
}
|
|
|
|
RootedObject breakdown(cx, ToObject(cx, breakdownValue));
|
|
if (!breakdown)
|
|
return nullptr;
|
|
|
|
RootedValue byValue(cx);
|
|
if (!GetProperty(cx, breakdown, breakdown, cx->names().by, &byValue))
|
|
return nullptr;
|
|
RootedString byString(cx, ToString(cx, byValue));
|
|
if (!byString)
|
|
return nullptr;
|
|
RootedLinearString by(cx, byString->ensureLinear(cx));
|
|
if (!by)
|
|
return nullptr;
|
|
|
|
if (StringEqualsAscii(by, "count")) {
|
|
RootedValue countValue(cx), bytesValue(cx);
|
|
if (!GetProperty(cx, breakdown, breakdown, cx->names().count, &countValue) ||
|
|
!GetProperty(cx, breakdown, breakdown, cx->names().bytes, &bytesValue))
|
|
return nullptr;
|
|
|
|
// Both 'count' and 'bytes' default to true if omitted, but ToBoolean
|
|
// naturally treats 'undefined' as false; fix this up.
|
|
if (countValue.isUndefined()) countValue.setBoolean(true);
|
|
if (bytesValue.isUndefined()) bytesValue.setBoolean(true);
|
|
|
|
// Undocumented feature, for testing: { by: 'count' } breakdowns can have
|
|
// a 'label' property whose value is converted to a string and included as
|
|
// a 'label' property on the report object.
|
|
RootedValue label(cx);
|
|
if (!GetProperty(cx, breakdown, breakdown, cx->names().label, &label))
|
|
return nullptr;
|
|
|
|
UniquePtr<char16_t[], JS::FreePolicy> labelUnique(nullptr);
|
|
if (!label.isUndefined()) {
|
|
RootedString labelString(cx, ToString(cx, label));
|
|
if (!labelString)
|
|
return nullptr;
|
|
|
|
JSFlatString* flat = labelString->ensureFlat(cx);
|
|
if (!flat)
|
|
return nullptr;
|
|
|
|
AutoStableStringChars chars(cx);
|
|
if (!chars.initTwoByte(cx, flat))
|
|
return nullptr;
|
|
|
|
// Since flat strings are null-terminated, and AutoStableStringChars
|
|
// null- terminates if it needs to make a copy, we know that
|
|
// chars.twoByteChars() is null-terminated.
|
|
labelUnique = DuplicateString(cx, chars.twoByteChars());
|
|
if (!labelUnique)
|
|
return nullptr;
|
|
}
|
|
|
|
CountTypePtr simple(census.new_<SimpleCount>(census,
|
|
labelUnique,
|
|
ToBoolean(countValue),
|
|
ToBoolean(bytesValue)));
|
|
return simple;
|
|
}
|
|
|
|
if (StringEqualsAscii(by, "objectClass")) {
|
|
CountTypePtr thenType(ParseChildBreakdown(census, breakdown, cx->names().then));
|
|
if (!thenType)
|
|
return nullptr;
|
|
|
|
CountTypePtr otherType(ParseChildBreakdown(census, breakdown, cx->names().other));
|
|
if (!otherType)
|
|
return nullptr;
|
|
|
|
return CountTypePtr(census.new_<ByObjectClass>(census, thenType, otherType));
|
|
}
|
|
|
|
if (StringEqualsAscii(by, "coarseType")) {
|
|
CountTypePtr objectsType(ParseChildBreakdown(census, breakdown, cx->names().objects));
|
|
if (!objectsType)
|
|
return nullptr;
|
|
CountTypePtr scriptsType(ParseChildBreakdown(census, breakdown, cx->names().scripts));
|
|
if (!scriptsType)
|
|
return nullptr;
|
|
CountTypePtr stringsType(ParseChildBreakdown(census, breakdown, cx->names().strings));
|
|
if (!stringsType)
|
|
return nullptr;
|
|
CountTypePtr otherType(ParseChildBreakdown(census, breakdown, cx->names().other));
|
|
if (!otherType)
|
|
return nullptr;
|
|
|
|
return CountTypePtr(census.new_<ByCoarseType>(census,
|
|
objectsType,
|
|
scriptsType,
|
|
stringsType,
|
|
otherType));
|
|
}
|
|
|
|
if (StringEqualsAscii(by, "internalType")) {
|
|
CountTypePtr thenType(ParseChildBreakdown(census, breakdown, cx->names().then));
|
|
if (!thenType)
|
|
return nullptr;
|
|
|
|
return CountTypePtr(census.new_<ByUbinodeType>(census, thenType));
|
|
}
|
|
|
|
if (StringEqualsAscii(by, "allocationStack")) {
|
|
CountTypePtr thenType(ParseChildBreakdown(census, breakdown, cx->names().then));
|
|
if (!thenType)
|
|
return nullptr;
|
|
CountTypePtr noStackType(ParseChildBreakdown(census, breakdown, cx->names().noStack));
|
|
if (!noStackType)
|
|
return nullptr;
|
|
|
|
return CountTypePtr(census.new_<ByAllocationStack>(census, thenType, noStackType));
|
|
}
|
|
|
|
if (StringEqualsAscii(by, "filename")) {
|
|
CountTypePtr thenType(ParseChildBreakdown(census, breakdown, cx->names().then));
|
|
if (!thenType)
|
|
return nullptr;
|
|
|
|
CountTypePtr noFilenameType(ParseChildBreakdown(census, breakdown, cx->names().noFilename));
|
|
if (!noFilenameType)
|
|
return nullptr;
|
|
|
|
return CountTypePtr(census.new_<ByFilename>(census, thenType, noFilenameType));
|
|
}
|
|
|
|
// We didn't recognize the breakdown type; complain.
|
|
RootedString bySource(cx, ValueToSource(cx, byValue));
|
|
if (!bySource)
|
|
return nullptr;
|
|
|
|
JSAutoByteString byBytes(cx, bySource);
|
|
if (!byBytes)
|
|
return nullptr;
|
|
|
|
JS_ReportErrorNumber(cx, GetErrorMessage, nullptr, JSMSG_DEBUG_CENSUS_BREAKDOWN,
|
|
byBytes.ptr());
|
|
return nullptr;
|
|
}
|
|
|
|
// Get the default census breakdown:
|
|
//
|
|
// { by: "coarseType",
|
|
// objects: { by: "objectClass" },
|
|
// other: { by: "internalType" }
|
|
// }
|
|
static CountTypePtr
|
|
GetDefaultBreakdown(Census& census)
|
|
{
|
|
CountTypePtr byClass(census.new_<SimpleCount>(census));
|
|
CountTypePtr byClassElse(census.new_<SimpleCount>(census));
|
|
CountTypePtr objects(census.new_<ByObjectClass>(census,
|
|
byClass,
|
|
byClassElse));
|
|
|
|
CountTypePtr scripts(census.new_<SimpleCount>(census));
|
|
CountTypePtr strings(census.new_<SimpleCount>(census));
|
|
|
|
CountTypePtr byType(census.new_<SimpleCount>(census));
|
|
CountTypePtr other(census.new_<ByUbinodeType>(census, byType));
|
|
|
|
return CountTypePtr(census.new_<ByCoarseType>(census,
|
|
objects,
|
|
scripts,
|
|
strings,
|
|
other));
|
|
}
|
|
|
|
bool
|
|
ParseCensusOptions(JSContext* cx, Census& census, HandleObject options, CountTypePtr& outResult)
|
|
{
|
|
RootedValue breakdown(cx, UndefinedValue());
|
|
if (options && !GetProperty(cx, options, options, cx->names().breakdown, &breakdown))
|
|
return false;
|
|
|
|
outResult = breakdown.isUndefined()
|
|
? GetDefaultBreakdown(census)
|
|
: ParseBreakdown(census, breakdown);
|
|
return !!outResult;
|
|
}
|
|
|
|
} // namespace ubi
|
|
} // namespace JS
|