debug-server-next
Version:
Dev server for hippy-core.
1,214 lines • 103 kB
JavaScript
/*
* Copyright (C) 2011 Google Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* eslint-disable rulesdir/no_underscored_properties */
import * as i18n from '../../core/i18n/i18n.js';
import * as Platform from '../../core/platform/platform.js';
import * as HeapSnapshotModel from '../../models/heap_snapshot_model/heap_snapshot_model.js';
import { AllocationProfile } from './AllocationProfile.js';
export class HeapSnapshotEdge {
_snapshot;
_edges;
edgeIndex;
constructor(snapshot, edgeIndex) {
this._snapshot = snapshot;
this._edges = snapshot.containmentEdges;
this.edgeIndex = edgeIndex || 0;
}
clone() {
return new HeapSnapshotEdge(this._snapshot, this.edgeIndex);
}
hasStringName() {
throw new Error('Not implemented');
}
name() {
throw new Error('Not implemented');
}
node() {
return this._snapshot.createNode(this.nodeIndex());
}
nodeIndex() {
if (typeof this._snapshot._edgeToNodeOffset === 'undefined') {
throw new Error('edgeToNodeOffset is undefined');
}
return this._edges[this.edgeIndex + this._snapshot._edgeToNodeOffset];
}
toString() {
return 'HeapSnapshotEdge: ' + this.name();
}
type() {
return this._snapshot._edgeTypes[this.rawType()];
}
itemIndex() {
return this.edgeIndex;
}
serialize() {
return new HeapSnapshotModel.HeapSnapshotModel.Edge(this.name(), this.node().serialize(), this.type(), this.edgeIndex);
}
rawType() {
if (typeof this._snapshot._edgeTypeOffset === 'undefined') {
throw new Error('edgeTypeOffset is undefined');
}
return this._edges[this.edgeIndex + this._snapshot._edgeTypeOffset];
}
isInvisible() {
throw new Error('Not implemented');
}
isWeak() {
throw new Error('Not implemented');
}
}
export class HeapSnapshotNodeIndexProvider {
_node;
constructor(snapshot) {
this._node = snapshot.createNode();
}
itemForIndex(index) {
this._node.nodeIndex = index;
return this._node;
}
}
export class HeapSnapshotEdgeIndexProvider {
_edge;
constructor(snapshot) {
this._edge = snapshot.createEdge(0);
}
itemForIndex(index) {
this._edge.edgeIndex = index;
return this._edge;
}
}
export class HeapSnapshotRetainerEdgeIndexProvider {
_retainerEdge;
constructor(snapshot) {
this._retainerEdge = snapshot.createRetainingEdge(0);
}
itemForIndex(index) {
this._retainerEdge.setRetainerIndex(index);
return this._retainerEdge;
}
}
export class HeapSnapshotEdgeIterator {
_sourceNode;
edge;
constructor(node) {
this._sourceNode = node;
this.edge = node._snapshot.createEdge(node.edgeIndexesStart());
}
hasNext() {
return this.edge.edgeIndex < this._sourceNode.edgeIndexesEnd();
}
item() {
return this.edge;
}
next() {
if (typeof this.edge._snapshot._edgeFieldsCount === 'undefined') {
throw new Error('edgeFieldsCount is undefined');
}
this.edge.edgeIndex += this.edge._snapshot._edgeFieldsCount;
}
}
export class HeapSnapshotRetainerEdge {
_snapshot;
_retainerIndex;
_globalEdgeIndex;
_retainingNodeIndex;
_edgeInstance;
_nodeInstance;
constructor(snapshot, retainerIndex) {
this._snapshot = snapshot;
this.setRetainerIndex(retainerIndex);
}
clone() {
return new HeapSnapshotRetainerEdge(this._snapshot, this.retainerIndex());
}
hasStringName() {
return this._edge().hasStringName();
}
name() {
return this._edge().name();
}
node() {
return this._node();
}
nodeIndex() {
if (typeof this._retainingNodeIndex === 'undefined') {
throw new Error('retainingNodeIndex is undefined');
}
return this._retainingNodeIndex;
}
retainerIndex() {
return this._retainerIndex;
}
setRetainerIndex(retainerIndex) {
if (retainerIndex === this._retainerIndex) {
return;
}
if (!this._snapshot._retainingEdges || !this._snapshot._retainingNodes) {
throw new Error('Snapshot does not contain retaining edges or retaining nodes');
}
this._retainerIndex = retainerIndex;
this._globalEdgeIndex = this._snapshot._retainingEdges[retainerIndex];
this._retainingNodeIndex = this._snapshot._retainingNodes[retainerIndex];
this._edgeInstance = null;
this._nodeInstance = null;
}
set edgeIndex(edgeIndex) {
this.setRetainerIndex(edgeIndex);
}
_node() {
if (!this._nodeInstance) {
this._nodeInstance = this._snapshot.createNode(this._retainingNodeIndex);
}
return this._nodeInstance;
}
_edge() {
if (!this._edgeInstance) {
this._edgeInstance = this._snapshot.createEdge(this._globalEdgeIndex);
}
return this._edgeInstance;
}
toString() {
return this._edge().toString();
}
itemIndex() {
return this._retainerIndex;
}
serialize() {
return new HeapSnapshotModel.HeapSnapshotModel.Edge(this.name(), this.node().serialize(), this.type(), this._globalEdgeIndex);
}
type() {
return this._edge().type();
}
}
export class HeapSnapshotRetainerEdgeIterator {
_retainersEnd;
retainer;
constructor(retainedNode) {
const snapshot = retainedNode._snapshot;
const retainedNodeOrdinal = retainedNode.ordinal();
if (!snapshot._firstRetainerIndex) {
throw new Error('Snapshot does not contain firstRetainerIndex');
}
const retainerIndex = snapshot._firstRetainerIndex[retainedNodeOrdinal];
this._retainersEnd = snapshot._firstRetainerIndex[retainedNodeOrdinal + 1];
this.retainer = snapshot.createRetainingEdge(retainerIndex);
}
hasNext() {
return this.retainer.retainerIndex() < this._retainersEnd;
}
item() {
return this.retainer;
}
next() {
this.retainer.setRetainerIndex(this.retainer.retainerIndex() + 1);
}
}
export class HeapSnapshotNode {
_snapshot;
nodeIndex;
constructor(snapshot, nodeIndex) {
this._snapshot = snapshot;
this.nodeIndex = nodeIndex || 0;
}
distance() {
return this._snapshot._nodeDistances[this.nodeIndex / this._snapshot._nodeFieldCount];
}
className() {
throw new Error('Not implemented');
}
classIndex() {
throw new Error('Not implemented');
}
dominatorIndex() {
const nodeFieldCount = this._snapshot._nodeFieldCount;
return this._snapshot._dominatorsTree[this.nodeIndex / this._snapshot._nodeFieldCount] * nodeFieldCount;
}
edges() {
return new HeapSnapshotEdgeIterator(this);
}
edgesCount() {
return (this.edgeIndexesEnd() - this.edgeIndexesStart()) / this._snapshot._edgeFieldsCount;
}
id() {
throw new Error('Not implemented');
}
rawName() {
throw new Error('Not implemented');
}
isRoot() {
return this.nodeIndex === this._snapshot._rootNodeIndex;
}
isUserRoot() {
throw new Error('Not implemented');
}
isHidden() {
throw new Error('Not implemented');
}
isArray() {
throw new Error('Not implemented');
}
isDocumentDOMTreesRoot() {
throw new Error('Not implemented');
}
name() {
return this._snapshot.strings[this._name()];
}
retainedSize() {
return this._snapshot._retainedSizes[this.ordinal()];
}
retainers() {
return new HeapSnapshotRetainerEdgeIterator(this);
}
retainersCount() {
const snapshot = this._snapshot;
const ordinal = this.ordinal();
return snapshot._firstRetainerIndex[ordinal + 1] - snapshot._firstRetainerIndex[ordinal];
}
selfSize() {
const snapshot = this._snapshot;
return snapshot.nodes[this.nodeIndex + snapshot._nodeSelfSizeOffset];
}
type() {
return this._snapshot._nodeTypes[this.rawType()];
}
traceNodeId() {
const snapshot = this._snapshot;
return snapshot.nodes[this.nodeIndex + snapshot._nodeTraceNodeIdOffset];
}
itemIndex() {
return this.nodeIndex;
}
serialize() {
return new HeapSnapshotModel.HeapSnapshotModel.Node(this.id(), this.name(), this.distance(), this.nodeIndex, this.retainedSize(), this.selfSize(), this.type());
}
_name() {
const snapshot = this._snapshot;
return snapshot.nodes[this.nodeIndex + snapshot._nodeNameOffset];
}
edgeIndexesStart() {
return this._snapshot._firstEdgeIndexes[this.ordinal()];
}
edgeIndexesEnd() {
return this._snapshot._firstEdgeIndexes[this.ordinal() + 1];
}
ordinal() {
return this.nodeIndex / this._snapshot._nodeFieldCount;
}
_nextNodeIndex() {
return this.nodeIndex + this._snapshot._nodeFieldCount;
}
rawType() {
const snapshot = this._snapshot;
return snapshot.nodes[this.nodeIndex + snapshot._nodeTypeOffset];
}
}
export class HeapSnapshotNodeIterator {
node;
_nodesLength;
constructor(node) {
this.node = node;
this._nodesLength = node._snapshot.nodes.length;
}
hasNext() {
return this.node.nodeIndex < this._nodesLength;
}
item() {
return this.node;
}
next() {
this.node.nodeIndex = this.node._nextNodeIndex();
}
}
export class HeapSnapshotIndexRangeIterator {
_itemProvider;
_indexes;
_position;
constructor(itemProvider, indexes) {
this._itemProvider = itemProvider;
this._indexes = indexes;
this._position = 0;
}
hasNext() {
return this._position < this._indexes.length;
}
item() {
const index = this._indexes[this._position];
return this._itemProvider.itemForIndex(index);
}
next() {
++this._position;
}
}
export class HeapSnapshotFilteredIterator {
_iterator;
_filter;
constructor(iterator, filter) {
this._iterator = iterator;
this._filter = filter;
this._skipFilteredItems();
}
hasNext() {
return this._iterator.hasNext();
}
item() {
return this._iterator.item();
}
next() {
this._iterator.next();
this._skipFilteredItems();
}
_skipFilteredItems() {
while (this._iterator.hasNext() && this._filter && !this._filter(this._iterator.item())) {
this._iterator.next();
}
}
}
export class HeapSnapshotProgress {
_dispatcher;
constructor(dispatcher) {
this._dispatcher = dispatcher;
}
updateStatus(status) {
this._sendUpdateEvent(i18n.i18n.serializeUIString(status));
}
updateProgress(title, value, total) {
const percentValue = ((total ? (value / total) : 0) * 100).toFixed(0);
this._sendUpdateEvent(i18n.i18n.serializeUIString(title, { PH1: percentValue }));
}
reportProblem(error) {
// May be undefined in tests.
if (this._dispatcher) {
this._dispatcher.sendEvent(HeapSnapshotModel.HeapSnapshotModel.HeapSnapshotProgressEvent.BrokenSnapshot, error);
}
}
_sendUpdateEvent(serializedText) {
// May be undefined in tests.
if (this._dispatcher) {
this._dispatcher.sendEvent(HeapSnapshotModel.HeapSnapshotModel.HeapSnapshotProgressEvent.Update, serializedText);
}
}
}
export class HeapSnapshotProblemReport {
_errors;
constructor(title) {
this._errors = [title];
}
addError(error) {
if (this._errors.length > 100) {
return;
}
this._errors.push(error);
}
toString() {
return this._errors.join('\n ');
}
}
export class HeapSnapshot {
nodes;
containmentEdges;
_metaNode;
_rawSamples;
_samples;
strings;
_locations;
_progress;
_noDistance;
_rootNodeIndex;
_snapshotDiffs;
_aggregatesForDiff;
_aggregates;
_aggregatesSortedFlags;
_profile;
_nodeTypeOffset;
_nodeNameOffset;
_nodeIdOffset;
_nodeSelfSizeOffset;
_nodeEdgeCountOffset;
_nodeTraceNodeIdOffset;
_nodeFieldCount;
_nodeTypes;
_nodeArrayType;
_nodeHiddenType;
_nodeObjectType;
_nodeNativeType;
_nodeConsStringType;
_nodeSlicedStringType;
_nodeCodeType;
_nodeSyntheticType;
_edgeFieldsCount;
_edgeTypeOffset;
_edgeNameOffset;
_edgeToNodeOffset;
_edgeTypes;
_edgeElementType;
_edgeHiddenType;
_edgeInternalType;
_edgeShortcutType;
_edgeWeakType;
_edgeInvisibleType;
_locationIndexOffset;
_locationScriptIdOffset;
_locationLineOffset;
_locationColumnOffset;
_locationFieldCount;
nodeCount;
_edgeCount;
_retainedSizes;
_firstEdgeIndexes;
_retainingNodes;
_retainingEdges;
_firstRetainerIndex;
_nodeDistances;
_firstDominatedNodeIndex;
_dominatedNodes;
_dominatorsTree;
_allocationProfile;
_nodeDetachednessOffset;
_locationMap;
_lazyStringCache;
constructor(profile, progress) {
this.nodes = profile.nodes;
this.containmentEdges = profile.edges;
this._metaNode = profile.snapshot.meta;
this._rawSamples = profile.samples;
this._samples = null;
this.strings = profile.strings;
this._locations = profile.locations;
this._progress = progress;
this._noDistance = -5;
this._rootNodeIndex = 0;
if (profile.snapshot.root_index) {
this._rootNodeIndex = profile.snapshot.root_index;
}
this._snapshotDiffs = {};
this._aggregates = {};
this._aggregatesSortedFlags = {};
this._profile = profile;
}
initialize() {
const meta = this._metaNode;
this._nodeTypeOffset = meta.node_fields.indexOf('type');
this._nodeNameOffset = meta.node_fields.indexOf('name');
this._nodeIdOffset = meta.node_fields.indexOf('id');
this._nodeSelfSizeOffset = meta.node_fields.indexOf('self_size');
this._nodeEdgeCountOffset = meta.node_fields.indexOf('edge_count');
this._nodeTraceNodeIdOffset = meta.node_fields.indexOf('trace_node_id');
this._nodeDetachednessOffset = meta.node_fields.indexOf('detachedness');
this._nodeFieldCount = meta.node_fields.length;
this._nodeTypes = meta.node_types[this._nodeTypeOffset];
this._nodeArrayType = this._nodeTypes.indexOf('array');
this._nodeHiddenType = this._nodeTypes.indexOf('hidden');
this._nodeObjectType = this._nodeTypes.indexOf('object');
this._nodeNativeType = this._nodeTypes.indexOf('native');
this._nodeConsStringType = this._nodeTypes.indexOf('concatenated string');
this._nodeSlicedStringType = this._nodeTypes.indexOf('sliced string');
this._nodeCodeType = this._nodeTypes.indexOf('code');
this._nodeSyntheticType = this._nodeTypes.indexOf('synthetic');
this._edgeFieldsCount = meta.edge_fields.length;
this._edgeTypeOffset = meta.edge_fields.indexOf('type');
this._edgeNameOffset = meta.edge_fields.indexOf('name_or_index');
this._edgeToNodeOffset = meta.edge_fields.indexOf('to_node');
this._edgeTypes = meta.edge_types[this._edgeTypeOffset];
this._edgeTypes.push('invisible');
this._edgeElementType = this._edgeTypes.indexOf('element');
this._edgeHiddenType = this._edgeTypes.indexOf('hidden');
this._edgeInternalType = this._edgeTypes.indexOf('internal');
this._edgeShortcutType = this._edgeTypes.indexOf('shortcut');
this._edgeWeakType = this._edgeTypes.indexOf('weak');
this._edgeInvisibleType = this._edgeTypes.indexOf('invisible');
const locationFields = meta.location_fields || [];
this._locationIndexOffset = locationFields.indexOf('object_index');
this._locationScriptIdOffset = locationFields.indexOf('script_id');
this._locationLineOffset = locationFields.indexOf('line');
this._locationColumnOffset = locationFields.indexOf('column');
this._locationFieldCount = locationFields.length;
this.nodeCount = this.nodes.length / this._nodeFieldCount;
this._edgeCount = this.containmentEdges.length / this._edgeFieldsCount;
this._retainedSizes = new Float64Array(this.nodeCount);
this._firstEdgeIndexes = new Uint32Array(this.nodeCount + 1);
this._retainingNodes = new Uint32Array(this._edgeCount);
this._retainingEdges = new Uint32Array(this._edgeCount);
this._firstRetainerIndex = new Uint32Array(this.nodeCount + 1);
this._nodeDistances = new Int32Array(this.nodeCount);
this._firstDominatedNodeIndex = new Uint32Array(this.nodeCount + 1);
this._dominatedNodes = new Uint32Array(this.nodeCount - 1);
this._progress.updateStatus('Building edge indexes…');
this._buildEdgeIndexes();
this._progress.updateStatus('Building retainers…');
this._buildRetainers();
this._progress.updateStatus('Propagating DOM state…');
this._propagateDOMState();
this._progress.updateStatus('Calculating node flags…');
this.calculateFlags();
this._progress.updateStatus('Calculating distances…');
this.calculateDistances();
this._progress.updateStatus('Building postorder index…');
const result = this._buildPostOrderIndex();
// Actually it is array that maps node ordinal number to dominator node ordinal number.
this._progress.updateStatus('Building dominator tree…');
this._dominatorsTree =
this._buildDominatorTree(result.postOrderIndex2NodeOrdinal, result.nodeOrdinal2PostOrderIndex);
this._progress.updateStatus('Calculating retained sizes…');
this._calculateRetainedSizes(result.postOrderIndex2NodeOrdinal);
this._progress.updateStatus('Building dominated nodes…');
this._buildDominatedNodes();
this._progress.updateStatus('Calculating statistics…');
this.calculateStatistics();
this._progress.updateStatus('Calculating samples…');
this._buildSamples();
this._progress.updateStatus('Building locations…');
this._buildLocationMap();
this._progress.updateStatus('Finished processing.');
if (this._profile.snapshot.trace_function_count) {
this._progress.updateStatus('Building allocation statistics…');
const nodes = this.nodes;
const nodesLength = nodes.length;
const nodeFieldCount = this._nodeFieldCount;
const node = this.rootNode();
const liveObjects = {};
for (let nodeIndex = 0; nodeIndex < nodesLength; nodeIndex += nodeFieldCount) {
node.nodeIndex = nodeIndex;
const traceNodeId = node.traceNodeId();
let stats = liveObjects[traceNodeId];
if (!stats) {
liveObjects[traceNodeId] = stats = { count: 0, size: 0, ids: [] };
}
stats.count++;
stats.size += node.selfSize();
stats.ids.push(node.id());
}
this._allocationProfile = new AllocationProfile(this._profile, liveObjects);
this._progress.updateStatus('done');
}
}
_buildEdgeIndexes() {
const nodes = this.nodes;
const nodeCount = this.nodeCount;
const firstEdgeIndexes = this._firstEdgeIndexes;
const nodeFieldCount = this._nodeFieldCount;
const edgeFieldsCount = this._edgeFieldsCount;
const nodeEdgeCountOffset = this._nodeEdgeCountOffset;
firstEdgeIndexes[nodeCount] = this.containmentEdges.length;
for (let nodeOrdinal = 0, edgeIndex = 0; nodeOrdinal < nodeCount; ++nodeOrdinal) {
firstEdgeIndexes[nodeOrdinal] = edgeIndex;
edgeIndex += nodes[nodeOrdinal * nodeFieldCount + nodeEdgeCountOffset] * edgeFieldsCount;
}
}
_buildRetainers() {
const retainingNodes = this._retainingNodes;
const retainingEdges = this._retainingEdges;
// Index of the first retainer in the _retainingNodes and _retainingEdges
// arrays. Addressed by retained node index.
const firstRetainerIndex = this._firstRetainerIndex;
const containmentEdges = this.containmentEdges;
const edgeFieldsCount = this._edgeFieldsCount;
const nodeFieldCount = this._nodeFieldCount;
const edgeToNodeOffset = this._edgeToNodeOffset;
const firstEdgeIndexes = this._firstEdgeIndexes;
const nodeCount = this.nodeCount;
for (let toNodeFieldIndex = edgeToNodeOffset, l = containmentEdges.length; toNodeFieldIndex < l; toNodeFieldIndex += edgeFieldsCount) {
const toNodeIndex = containmentEdges[toNodeFieldIndex];
if (toNodeIndex % nodeFieldCount) {
throw new Error('Invalid toNodeIndex ' + toNodeIndex);
}
++firstRetainerIndex[toNodeIndex / nodeFieldCount];
}
for (let i = 0, firstUnusedRetainerSlot = 0; i < nodeCount; i++) {
const retainersCount = firstRetainerIndex[i];
firstRetainerIndex[i] = firstUnusedRetainerSlot;
retainingNodes[firstUnusedRetainerSlot] = retainersCount;
firstUnusedRetainerSlot += retainersCount;
}
firstRetainerIndex[nodeCount] = retainingNodes.length;
let nextNodeFirstEdgeIndex = firstEdgeIndexes[0];
for (let srcNodeOrdinal = 0; srcNodeOrdinal < nodeCount; ++srcNodeOrdinal) {
const firstEdgeIndex = nextNodeFirstEdgeIndex;
nextNodeFirstEdgeIndex = firstEdgeIndexes[srcNodeOrdinal + 1];
const srcNodeIndex = srcNodeOrdinal * nodeFieldCount;
for (let edgeIndex = firstEdgeIndex; edgeIndex < nextNodeFirstEdgeIndex; edgeIndex += edgeFieldsCount) {
const toNodeIndex = containmentEdges[edgeIndex + edgeToNodeOffset];
if (toNodeIndex % nodeFieldCount) {
throw new Error('Invalid toNodeIndex ' + toNodeIndex);
}
const firstRetainerSlotIndex = firstRetainerIndex[toNodeIndex / nodeFieldCount];
const nextUnusedRetainerSlotIndex = firstRetainerSlotIndex + (--retainingNodes[firstRetainerSlotIndex]);
retainingNodes[nextUnusedRetainerSlotIndex] = srcNodeIndex;
retainingEdges[nextUnusedRetainerSlotIndex] = edgeIndex;
}
}
}
_allNodes() {
return new HeapSnapshotNodeIterator(this.rootNode());
}
rootNode() {
return this.createNode(this._rootNodeIndex);
}
get rootNodeIndex() {
return this._rootNodeIndex;
}
get totalSize() {
return this.rootNode().retainedSize();
}
_getDominatedIndex(nodeIndex) {
if (nodeIndex % this._nodeFieldCount) {
throw new Error('Invalid nodeIndex: ' + nodeIndex);
}
return this._firstDominatedNodeIndex[nodeIndex / this._nodeFieldCount];
}
_createFilter(nodeFilter) {
const minNodeId = nodeFilter.minNodeId;
const maxNodeId = nodeFilter.maxNodeId;
const allocationNodeId = nodeFilter.allocationNodeId;
let filter;
if (typeof allocationNodeId === 'number') {
filter = this._createAllocationStackFilter(allocationNodeId);
if (!filter) {
throw new Error('Unable to create filter');
}
// @ts-ignore key can be added as a static property
filter.key = 'AllocationNodeId: ' + allocationNodeId;
}
else if (typeof minNodeId === 'number' && typeof maxNodeId === 'number') {
filter = this._createNodeIdFilter(minNodeId, maxNodeId);
// @ts-ignore key can be added as a static property
filter.key = 'NodeIdRange: ' + minNodeId + '..' + maxNodeId;
}
return filter;
}
search(searchConfig, nodeFilter) {
const query = searchConfig.query;
function filterString(matchedStringIndexes, string, index) {
if (string.indexOf(query) !== -1) {
matchedStringIndexes.add(index);
}
return matchedStringIndexes;
}
const regexp = searchConfig.isRegex ? new RegExp(query) : createPlainTextSearchRegex(query, 'i');
function filterRegexp(matchedStringIndexes, string, index) {
if (regexp.test(string)) {
matchedStringIndexes.add(index);
}
return matchedStringIndexes;
}
const stringFilter = (searchConfig.isRegex || !searchConfig.caseSensitive) ? filterRegexp : filterString;
const stringIndexes = this.strings.reduce(stringFilter, new Set());
if (!stringIndexes.size) {
return [];
}
const filter = this._createFilter(nodeFilter);
const nodeIds = [];
const nodesLength = this.nodes.length;
const nodes = this.nodes;
const nodeNameOffset = this._nodeNameOffset;
const nodeIdOffset = this._nodeIdOffset;
const nodeFieldCount = this._nodeFieldCount;
const node = this.rootNode();
for (let nodeIndex = 0; nodeIndex < nodesLength; nodeIndex += nodeFieldCount) {
node.nodeIndex = nodeIndex;
if (filter && !filter(node)) {
continue;
}
if (stringIndexes.has(nodes[nodeIndex + nodeNameOffset])) {
nodeIds.push(nodes[nodeIndex + nodeIdOffset]);
}
}
return nodeIds;
}
aggregatesWithFilter(nodeFilter) {
const filter = this._createFilter(nodeFilter);
// @ts-ignore key is added in _createFilter
const key = filter ? filter.key : 'allObjects';
return this.getAggregatesByClassName(false, key, filter);
}
_createNodeIdFilter(minNodeId, maxNodeId) {
function nodeIdFilter(node) {
const id = node.id();
return id > minNodeId && id <= maxNodeId;
}
return nodeIdFilter;
}
_createAllocationStackFilter(bottomUpAllocationNodeId) {
if (!this._allocationProfile) {
throw new Error('No Allocation Profile provided');
}
const traceIds = this._allocationProfile.traceIds(bottomUpAllocationNodeId);
if (!traceIds.length) {
return undefined;
}
const set = {};
for (let i = 0; i < traceIds.length; i++) {
set[traceIds[i]] = true;
}
function traceIdFilter(node) {
return Boolean(set[node.traceNodeId()]);
}
return traceIdFilter;
}
getAggregatesByClassName(sortedIndexes, key, filter) {
const aggregates = this._buildAggregates(filter);
let aggregatesByClassName;
if (key && this._aggregates[key]) {
aggregatesByClassName = this._aggregates[key];
}
else {
this._calculateClassesRetainedSize(aggregates.aggregatesByClassIndex, filter);
aggregatesByClassName = aggregates.aggregatesByClassName;
if (key) {
this._aggregates[key] = aggregatesByClassName;
}
}
if (sortedIndexes && (!key || !this._aggregatesSortedFlags[key])) {
this._sortAggregateIndexes(aggregates.aggregatesByClassName);
if (key) {
this._aggregatesSortedFlags[key] = sortedIndexes;
}
}
return aggregatesByClassName;
}
allocationTracesTops() {
return this._allocationProfile.serializeTraceTops();
}
allocationNodeCallers(nodeId) {
return this._allocationProfile.serializeCallers(nodeId);
}
allocationStack(nodeIndex) {
const node = this.createNode(nodeIndex);
const allocationNodeId = node.traceNodeId();
if (!allocationNodeId) {
return null;
}
return this._allocationProfile.serializeAllocationStack(allocationNodeId);
}
aggregatesForDiff() {
if (this._aggregatesForDiff) {
return this._aggregatesForDiff;
}
const aggregatesByClassName = this.getAggregatesByClassName(true, 'allObjects');
this._aggregatesForDiff = {};
const node = this.createNode();
for (const className in aggregatesByClassName) {
const aggregate = aggregatesByClassName[className];
const indexes = aggregate.idxs;
const ids = new Array(indexes.length);
const selfSizes = new Array(indexes.length);
for (let i = 0; i < indexes.length; i++) {
node.nodeIndex = indexes[i];
ids[i] = node.id();
selfSizes[i] = node.selfSize();
}
this._aggregatesForDiff[className] = { indexes: indexes, ids: ids, selfSizes: selfSizes };
}
return this._aggregatesForDiff;
}
isUserRoot(_node) {
return true;
}
calculateDistances(filter) {
const nodeCount = this.nodeCount;
const distances = this._nodeDistances;
const noDistance = this._noDistance;
for (let i = 0; i < nodeCount; ++i) {
distances[i] = noDistance;
}
const nodesToVisit = new Uint32Array(this.nodeCount);
let nodesToVisitLength = 0;
// BFS for user root objects.
for (let iter = this.rootNode().edges(); iter.hasNext(); iter.next()) {
const node = iter.edge.node();
if (this.isUserRoot(node)) {
distances[node.ordinal()] = 1;
nodesToVisit[nodesToVisitLength++] = node.nodeIndex;
}
}
this._bfs(nodesToVisit, nodesToVisitLength, distances, filter);
// BFS for objects not reached from user roots.
distances[this.rootNode().ordinal()] =
nodesToVisitLength > 0 ? HeapSnapshotModel.HeapSnapshotModel.baseSystemDistance : 0;
nodesToVisit[0] = this.rootNode().nodeIndex;
nodesToVisitLength = 1;
this._bfs(nodesToVisit, nodesToVisitLength, distances, filter);
}
_bfs(nodesToVisit, nodesToVisitLength, distances, filter) {
// Preload fields into local variables for better performance.
const edgeFieldsCount = this._edgeFieldsCount;
const nodeFieldCount = this._nodeFieldCount;
const containmentEdges = this.containmentEdges;
const firstEdgeIndexes = this._firstEdgeIndexes;
const edgeToNodeOffset = this._edgeToNodeOffset;
const edgeTypeOffset = this._edgeTypeOffset;
const nodeCount = this.nodeCount;
const edgeWeakType = this._edgeWeakType;
const noDistance = this._noDistance;
let index = 0;
const edge = this.createEdge(0);
const node = this.createNode(0);
while (index < nodesToVisitLength) {
const nodeIndex = nodesToVisit[index++]; // shift generates too much garbage.
const nodeOrdinal = nodeIndex / nodeFieldCount;
const distance = distances[nodeOrdinal] + 1;
const firstEdgeIndex = firstEdgeIndexes[nodeOrdinal];
const edgesEnd = firstEdgeIndexes[nodeOrdinal + 1];
node.nodeIndex = nodeIndex;
for (let edgeIndex = firstEdgeIndex; edgeIndex < edgesEnd; edgeIndex += edgeFieldsCount) {
const edgeType = containmentEdges[edgeIndex + edgeTypeOffset];
if (edgeType === edgeWeakType) {
continue;
}
const childNodeIndex = containmentEdges[edgeIndex + edgeToNodeOffset];
const childNodeOrdinal = childNodeIndex / nodeFieldCount;
if (distances[childNodeOrdinal] !== noDistance) {
continue;
}
edge.edgeIndex = edgeIndex;
if (filter && !filter(node, edge)) {
continue;
}
distances[childNodeOrdinal] = distance;
nodesToVisit[nodesToVisitLength++] = childNodeIndex;
}
}
if (nodesToVisitLength > nodeCount) {
throw new Error('BFS failed. Nodes to visit (' + nodesToVisitLength + ') is more than nodes count (' + nodeCount + ')');
}
}
_buildAggregates(filter) {
const aggregates = {};
const aggregatesByClassName = {};
const classIndexes = [];
const nodes = this.nodes;
const nodesLength = nodes.length;
const nodeNativeType = this._nodeNativeType;
const nodeFieldCount = this._nodeFieldCount;
const selfSizeOffset = this._nodeSelfSizeOffset;
const nodeTypeOffset = this._nodeTypeOffset;
const node = this.rootNode();
const nodeDistances = this._nodeDistances;
for (let nodeIndex = 0; nodeIndex < nodesLength; nodeIndex += nodeFieldCount) {
node.nodeIndex = nodeIndex;
if (filter && !filter(node)) {
continue;
}
const selfSize = nodes[nodeIndex + selfSizeOffset];
if (!selfSize && nodes[nodeIndex + nodeTypeOffset] !== nodeNativeType) {
continue;
}
const classIndex = node.classIndex();
const nodeOrdinal = nodeIndex / nodeFieldCount;
const distance = nodeDistances[nodeOrdinal];
if (!(classIndex in aggregates)) {
const nodeType = node.type();
const nameMatters = nodeType === 'object' || nodeType === 'native';
const value = {
count: 1,
distance: distance,
self: selfSize,
maxRet: 0,
type: nodeType,
name: nameMatters ? node.name() : null,
idxs: [nodeIndex],
};
aggregates[classIndex] = value;
classIndexes.push(classIndex);
aggregatesByClassName[node.className()] = value;
}
else {
const clss = aggregates[classIndex];
if (!clss) {
continue;
}
clss.distance = Math.min(clss.distance, distance);
++clss.count;
clss.self += selfSize;
clss.idxs.push(nodeIndex);
}
}
// Shave off provisionally allocated space.
for (let i = 0, l = classIndexes.length; i < l; ++i) {
const classIndex = classIndexes[i];
const classIndexValues = aggregates[classIndex];
if (!classIndexValues) {
continue;
}
classIndexValues.idxs = classIndexValues.idxs.slice();
}
return { aggregatesByClassName: aggregatesByClassName, aggregatesByClassIndex: aggregates };
}
_calculateClassesRetainedSize(aggregates, filter) {
const rootNodeIndex = this._rootNodeIndex;
const node = this.createNode(rootNodeIndex);
const list = [rootNodeIndex];
const sizes = [-1];
const classes = [];
const seenClassNameIndexes = new Map();
const nodeFieldCount = this._nodeFieldCount;
const nodeTypeOffset = this._nodeTypeOffset;
const nodeNativeType = this._nodeNativeType;
const dominatedNodes = this._dominatedNodes;
const nodes = this.nodes;
const firstDominatedNodeIndex = this._firstDominatedNodeIndex;
while (list.length) {
const nodeIndex = list.pop();
node.nodeIndex = nodeIndex;
let classIndex = node.classIndex();
const seen = Boolean(seenClassNameIndexes.get(classIndex));
const nodeOrdinal = nodeIndex / nodeFieldCount;
const dominatedIndexFrom = firstDominatedNodeIndex[nodeOrdinal];
const dominatedIndexTo = firstDominatedNodeIndex[nodeOrdinal + 1];
if (!seen && (!filter || filter(node)) &&
(node.selfSize() || nodes[nodeIndex + nodeTypeOffset] === nodeNativeType)) {
aggregates[classIndex].maxRet += node.retainedSize();
if (dominatedIndexFrom !== dominatedIndexTo) {
seenClassNameIndexes.set(classIndex, true);
sizes.push(list.length);
classes.push(classIndex);
}
}
for (let i = dominatedIndexFrom; i < dominatedIndexTo; i++) {
list.push(dominatedNodes[i]);
}
const l = list.length;
while (sizes[sizes.length - 1] === l) {
sizes.pop();
classIndex = classes.pop();
seenClassNameIndexes.set(classIndex, false);
}
}
}
_sortAggregateIndexes(aggregates) {
const nodeA = this.createNode();
const nodeB = this.createNode();
for (const clss in aggregates) {
aggregates[clss].idxs.sort((idxA, idxB) => {
nodeA.nodeIndex = idxA;
nodeB.nodeIndex = idxB;
return nodeA.id() < nodeB.id() ? -1 : 1;
});
}
}
/**
* The function checks is the edge should be considered during building
* postorder iterator and dominator tree.
*/
_isEssentialEdge(nodeIndex, edgeType) {
// Shortcuts at the root node have special meaning of marking user global objects.
return edgeType !== this._edgeWeakType &&
(edgeType !== this._edgeShortcutType || nodeIndex === this._rootNodeIndex);
}
_buildPostOrderIndex() {
const nodeFieldCount = this._nodeFieldCount;
const nodeCount = this.nodeCount;
const rootNodeOrdinal = this._rootNodeIndex / nodeFieldCount;
const edgeFieldsCount = this._edgeFieldsCount;
const edgeTypeOffset = this._edgeTypeOffset;
const edgeToNodeOffset = this._edgeToNodeOffset;
const firstEdgeIndexes = this._firstEdgeIndexes;
const containmentEdges = this.containmentEdges;
const mapAndFlag = this.userObjectsMapAndFlag();
const flags = mapAndFlag ? mapAndFlag.map : null;
const flag = mapAndFlag ? mapAndFlag.flag : 0;
const stackNodes = new Uint32Array(nodeCount);
const stackCurrentEdge = new Uint32Array(nodeCount);
const postOrderIndex2NodeOrdinal = new Uint32Array(nodeCount);
const nodeOrdinal2PostOrderIndex = new Uint32Array(nodeCount);
const visited = new Uint8Array(nodeCount);
let postOrderIndex = 0;
let stackTop = 0;
stackNodes[0] = rootNodeOrdinal;
stackCurrentEdge[0] = firstEdgeIndexes[rootNodeOrdinal];
visited[rootNodeOrdinal] = 1;
let iteration = 0;
while (true) {
++iteration;
while (stackTop >= 0) {
const nodeOrdinal = stackNodes[stackTop];
const edgeIndex = stackCurrentEdge[stackTop];
const edgesEnd = firstEdgeIndexes[nodeOrdinal + 1];
if (edgeIndex < edgesEnd) {
stackCurrentEdge[stackTop] += edgeFieldsCount;
const edgeType = containmentEdges[edgeIndex + edgeTypeOffset];
if (!this._isEssentialEdge(nodeOrdinal * nodeFieldCount, edgeType)) {
continue;
}
const childNodeIndex = containmentEdges[edgeIndex + edgeToNodeOffset];
const childNodeOrdinal = childNodeIndex / nodeFieldCount;
if (visited[childNodeOrdinal]) {
continue;
}
const nodeFlag = !flags || (flags[nodeOrdinal] & flag);
const childNodeFlag = !flags || (flags[childNodeOrdinal] & flag);
// We are skipping the edges from non-page-owned nodes to page-owned nodes.
// Otherwise the dominators for the objects that also were retained by debugger would be affected.
if (nodeOrdinal !== rootNodeOrdinal && childNodeFlag && !nodeFlag) {
continue;
}
++stackTop;
stackNodes[stackTop] = childNodeOrdinal;
stackCurrentEdge[stackTop] = firstEdgeIndexes[childNodeOrdinal];
visited[childNodeOrdinal] = 1;
}
else {
// Done with all the node children
nodeOrdinal2PostOrderIndex[nodeOrdinal] = postOrderIndex;
postOrderIndex2NodeOrdinal[postOrderIndex++] = nodeOrdinal;
--stackTop;
}
}
if (postOrderIndex === nodeCount || iteration > 1) {
break;
}
const errors = new HeapSnapshotProblemReport(`Heap snapshot: ${nodeCount - postOrderIndex} nodes are unreachable from the root. Following nodes have only weak retainers:`);
const dumpNode = this.rootNode();
// Remove root from the result (last node in the array) and put it at the bottom of the stack so that it is
// visited after all orphan nodes and their subgraphs.
--postOrderIndex;
stackTop = 0;
stackNodes[0] = rootNodeOrdinal;
stackCurrentEdge[0] = firstEdgeIndexes[rootNodeOrdinal + 1]; // no need to reiterate its edges
for (let i = 0; i < nodeCount; ++i) {
if (visited[i] || !this._hasOnlyWeakRetainers(i)) {
continue;
}
// Add all nodes that have only weak retainers to traverse their subgraphs.
stackNodes[++stackTop] = i;
stackCurrentEdge[stackTop] = firstEdgeIndexes[i];
visited[i] = 1;
dumpNode.nodeIndex = i * nodeFieldCount;
const retainers = [];
for (let it = dumpNode.retainers(); it.hasNext(); it.next()) {
retainers.push(`${it.item().node().name()}@${it.item().node().id()}.${it.item().name()}`);
}
errors.addError(`${dumpNode.name()} @${dumpNode.id()} weak retainers: ${retainers.join(', ')}`);
}
console.warn(errors.toString());
}
// If we already processed all orphan nodes that have only weak retainers and still have some orphans...
if (postOrderIndex !== nodeCount) {
const errors = new HeapSnapshotProblemReport('Still found ' + (nodeCount - postOrderIndex) + ' unreachable nodes in heap snapshot:');
const dumpNode = this.rootNode();
// Remove root from the result (last node in the array) and put it at the bottom of the stack so that it is
// visited after all orphan nodes and their subgraphs.
--postOrderIndex;
for (let i = 0; i < nodeCount; ++i) {
if (visited[i]) {
continue;
}
dumpNode.nodeIndex = i * nodeFieldCount;
errors.addError(dumpNode.name() + ' @' + dumpNode.id());
// Fix it by giving the node a postorder index anyway.
nodeOrdinal2PostOrderIndex[i] = postOrderIndex;
postOrderIndex2NodeOrdinal[postOrderIndex++] = i;
}
nodeOrdinal2PostOrderIndex[rootNodeOrdinal] = postOrderIndex;
postOrderIndex2NodeOrdinal[postOrderIndex++] = rootNodeOrdinal;
console.warn(errors.toString());
}
return {
postOrderIndex2NodeOrdinal: postOrderIndex2NodeOrdinal,
nodeOrdinal2PostOrderIndex: nodeOrdinal2PostOrderIndex,
};
}
_hasOnlyWeakRetainers(nodeOrdinal) {
const edgeTypeOffset = this._edgeTypeOffset;
const edgeWeakType = this._edgeWeakType;
const edgeShortcutType = this._edgeShortcutType;
const containmentEdges = this.containmentEdges;
const retainingEdges = this._retainingEdges;
const beginRetainerIndex = this._firstRetainerIndex[nodeOrdinal];
const endRetainerIndex = this._firstRetainerIndex[nodeOrdinal + 1];
for (let retainerIndex = beginRetainerIndex; retainerIndex < endRetainerIndex; ++retainerIndex) {
const retainerEdgeIndex = retainingEdges[retainerIndex];
const retainerEdgeType = containmentEdges[retainerEdgeIndex + edgeTypeOffset];
if (retainerEdgeType !== edgeWeakType && retainerEdgeType !== edgeShortcutType) {
return false;
}
}
return true;
}
// The algorithm is based on the article:
// K. Cooper, T. Harvey and K. Kennedy "A Simple, Fast Dominance Algorithm"
// Softw. Pract. Exper. 4 (2001), pp. 1-10.
_buildDominatorTree(postOrderIndex2NodeOrdinal, nodeOrdinal2PostOrderIndex) {
const nodeFieldCount = this._nodeFieldCount;
const firstRetainerIndex = this._firstRetainerIndex;
const retainingNodes = this._retainingNodes;
const retainingEdges = this._retainingEdges;
const edgeFieldsCount = this._edgeFieldsCount;
const edgeTypeOffset = this._edgeTypeOffset;
const edgeToNodeOffset = this._edgeToNodeOffset;
const firstEdgeIndexes = this._firstEdgeIndexes;
const containmentEdges = this.containmentEdges;
const rootNodeIndex = this._rootNodeIndex;
const mapAndFlag = this.userObjectsMapAndFlag();
const flags = mapAndFlag ? mapAndFlag.map : null;
const flag = mapAndFlag ? mapAndFlag.flag : 0;
const nodesCount = postOrderIndex2NodeOrdinal.length;
const rootPostOrderedIndex = nodesCount - 1;
const noEntry = nodesCount;
const dominators = new Uint32Array(nodesCount);
for (let i = 0; i < rootPostOrderedIndex; ++i) {
dominators[i] = noEntry;
}
dominators[rootPostOrderedIndex] = rootPostOrderedIndex;
// The affected array is used to mark entries which dominators
// have to be racalculated because of changes in their retainers.
const affected = new Uint8Array(nodesCount);
let nodeOrdinal;
{ // Mark the root direct children as affected.
nodeOrdinal = this._rootNodeIndex / nodeFieldCount;
const endEdgeIndex = firstEdgeIndexes[nodeOrdinal + 1];
for (let edgeIndex = firstEdgeIndexes[nodeOrdinal]; edgeIndex < endEdgeIndex; edgeIndex += edgeFieldsCount) {
const edgeType = containmentEdges[edgeIndex + edgeTypeOffset];
if (!this._isEssentialEdge(this._rootNodeIndex, edgeType)) {
continue;
}
const childNodeOrdinal = containmentEdges[edgeIndex + edgeToNodeOffset] / nodeFieldCount;
affected[nodeOrdinal2PostOrderIndex[childNodeOrdinal]] = 1;
}
}
let changed = true;
while (changed) {
changed = false;
for (let postOrderIndex = rootPostOrderedIndex - 1; postOrderIndex >= 0; --postOrderIndex) {
if (affected[postOrderIndex] === 0) {
continue;
}
affected[postOrderIndex] = 0;
// If dominator of the entry has already been set to root,
// then it can't propagate any further.
if (dominators[postOrderIndex] === rootPostOrderedIndex) {
continue;
}
nodeOrdinal = postOrderIndex2NodeOrdinal[postOrderIndex];
const nodeFlag = !flags || (flags[nodeOrdinal] & flag);
let newDominatorIndex = noEntry;
const beginRetainerIndex = firstRetainerIndex[nodeOrdinal];
const endRetainerIndex = firstRetainerIndex[nodeOrdinal + 1];
let orphanNode = true;
for (let retainerIndex = beginRetainerIndex; retainerIndex < endRetainerInde